2014-03-20 15:04:56 -05: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-22 12:50:50 -05:00
import (
2015-08-10 01:42:50 -05:00
"fmt"
2017-03-03 09:35:42 -05:00
"path"
2018-01-03 03:34:13 -05:00
"regexp"
2017-01-30 07:46:45 -05:00
"sort"
2014-03-22 12:50:50 -05:00
"strings"
2014-05-07 15:51:14 -05:00
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2017-01-24 21:43:02 -05:00
"code.gitea.io/gitea/modules/util"
2017-12-25 18:25:16 -05:00
api "code.gitea.io/sdk/gitea"
"github.com/Unknwon/com"
"github.com/go-xorm/builder"
"github.com/go-xorm/xorm"
2014-03-22 12:50:50 -05:00
)
// Issue represents an issue or pull request of repository.
2014-03-20 15:04:56 -05:00
type Issue struct {
2016-08-14 05:32:24 -05:00
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"INDEX UNIQUE(repo_index)" `
2014-03-29 09:24:42 -05:00
Repo * Repository ` xorm:"-" `
2016-08-16 12:19:09 -05:00
Index int64 ` xorm:"UNIQUE(repo_index)" ` // Index in one repository.
2017-01-06 10:14:33 -05: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-16 12:19:09 -05:00
Priority int
2018-05-09 11:29:04 -05:00
AssigneeID int64 ` xorm:"-" `
2017-01-06 10:14:33 -05:00
Assignee * User ` xorm:"-" `
IsClosed bool ` xorm:"INDEX" `
2016-08-16 12:19:09 -05:00
IsRead bool ` xorm:"-" `
2017-01-06 10:14:33 -05:00
IsPull bool ` xorm:"INDEX" ` // Indicates whether is a pull request or not.
2016-08-16 12:19:09 -05:00
PullRequest * PullRequest ` xorm:"-" `
2014-03-29 09:24:42 -05:00
NumComments int
2017-08-24 07:30:27 -05:00
Ref string
2016-03-09 19:53:30 -05:00
2017-12-10 23:37:04 -05:00
DeadlineUnix util . TimeStamp ` xorm:"INDEX" `
2018-05-01 14:05:28 -05:00
CreatedUnix util . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix util . TimeStamp ` xorm:"INDEX updated" `
ClosedUnix util . TimeStamp ` xorm:"INDEX" `
2015-08-12 04:04:23 -05:00
2018-04-29 00:58:47 -05:00
Attachments [ ] * Attachment ` xorm:"-" `
Comments [ ] * Comment ` xorm:"-" `
Reactions ReactionList ` xorm:"-" `
TotalTrackedTime int64 ` xorm:"-" `
2018-05-09 11:29:04 -05:00
Assignees [ ] * User ` xorm:"-" `
2015-08-12 04:04:23 -05:00
}
2018-01-03 03:34:13 -05:00
var (
issueTasksPat * regexp . Regexp
issueTasksDonePat * regexp . Regexp
)
2018-01-03 14:45:21 -05: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 03:34:13 -05:00
func init ( ) {
issueTasksPat = regexp . MustCompile ( issueTasksRegexpStr )
issueTasksDonePat = regexp . MustCompile ( issueTasksDoneRegexpStr )
}
2018-04-29 00:58:47 -05: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-01 14:05:28 -05:00
// IsOverdue checks if the issue is overdue
func ( issue * Issue ) IsOverdue ( ) bool {
return util . TimeStampNow ( ) >= issue . DeadlineUnix
}
2018-12-13 10:55:43 -05:00
// LoadRepo loads issue's repository
func ( issue * Issue ) LoadRepo ( ) error {
return issue . loadRepo ( x )
}
2016-12-17 06:49:17 -05:00
func ( issue * Issue ) loadRepo ( e Engine ) ( err error ) {
2016-08-26 15:40:53 -05:00
if issue . Repo == nil {
issue . Repo , err = getRepositoryByID ( e , issue . RepoID )
2016-03-13 22:20:22 -05:00
if err != nil {
2016-08-26 15:40:53 -05:00
return fmt . Errorf ( "getRepositoryByID [%d]: %v" , issue . RepoID , err )
2016-03-13 22:20:22 -05:00
}
2016-08-26 15:40:53 -05:00
}
2016-12-17 06:49:17 -05:00
return nil
}
2018-04-29 00:58:47 -05:00
// IsTimetrackerEnabled returns true if the repo enables timetracking
func ( issue * Issue ) IsTimetrackerEnabled ( ) bool {
2019-01-13 21:29:58 -05:00
return issue . isTimetrackerEnabled ( x )
}
func ( issue * Issue ) isTimetrackerEnabled ( e Engine ) bool {
if err := issue . loadRepo ( e ) ; err != nil {
2018-04-29 00:58:47 -05:00
log . Error ( 4 , fmt . Sprintf ( "loadRepo: %v" , err ) )
return false
}
return issue . Repo . IsTimetrackerEnabled ( )
}
2017-01-28 11:01:07 -05: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 )
2018-10-18 06:23:05 -05:00
if err != nil {
return nil , err
}
pr . Issue = issue
2017-01-28 11:01:07 -05:00
return
}
2017-01-30 07:46:45 -05: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 06:49:17 -05:00
}
2017-01-30 07:46:45 -05:00
return nil
}
2016-03-13 22:20:22 -05:00
2018-12-13 10:55:43 -05:00
// LoadPoster loads poster
func ( issue * Issue ) LoadPoster ( ) error {
return issue . loadPoster ( x )
}
2017-01-30 07:46:45 -05:00
func ( issue * Issue ) loadPoster ( e Engine ) ( err error ) {
2016-08-26 15:40:53 -05:00
if issue . Poster == nil {
issue . Poster , err = getUserByID ( e , issue . PosterID )
2016-03-13 22:20:22 -05:00
if err != nil {
2016-09-20 04:54:47 -05:00
issue . PosterID = - 1
issue . Poster = NewGhostUser ( )
2016-11-04 13:47:54 -05:00
if ! IsErrUserNotExist ( err ) {
2016-08-26 15:40:53 -05:00
return fmt . Errorf ( "getUserByID.(poster) [%d]: %v" , issue . PosterID , err )
2016-03-13 22:20:22 -05:00
}
2016-11-09 00:07:01 -05:00
err = nil
2016-03-13 22:20:22 -05:00
return
}
2016-08-26 15:40:53 -05:00
}
2017-01-30 07:46:45 -05:00
return
}
2016-03-13 22:20:22 -05:00
2017-07-26 02:16:45 -05: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 )
}
2018-12-13 10:55:43 -05:00
issue . PullRequest . Issue = issue
2017-07-26 02:16:45 -05:00
}
return nil
}
2018-12-13 10:55:43 -05:00
// LoadPullRequest loads pull request info
func ( issue * Issue ) LoadPullRequest ( ) error {
return issue . loadPullRequest ( x )
}
2017-09-16 15:16:21 -05: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-03 18:14:26 -05: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
2019-01-13 21:29:58 -05:00
if _ , err := ReactionList ( reactions ) . loadUsers ( e ) ; err != nil {
2017-12-03 18:14:26 -05:00
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 07:46:45 -05: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-26 15:40:53 -05:00
}
2015-08-10 08:47:23 -05:00
2016-08-26 15:40:53 -05:00
if issue . Milestone == nil && issue . MilestoneID > 0 {
issue . Milestone , err = getMilestoneByRepoID ( e , issue . RepoID , issue . MilestoneID )
2017-08-11 21:15:30 -05:00
if err != nil && ! IsErrMilestoneNotExist ( err ) {
2016-08-26 15:40:53 -05:00
return fmt . Errorf ( "getMilestoneByRepoID [repo_id: %d, milestone_id: %d]: %v" , issue . RepoID , issue . MilestoneID , err )
2015-08-10 08:47:23 -05:00
}
2015-08-05 07:23:08 -05:00
}
2018-05-09 11:29:04 -05:00
if err = issue . loadAssignees ( e ) ; err != nil {
2017-06-23 08:43:37 -05:00
return
2016-08-14 05:32:24 -05:00
}
2017-07-26 02:16:45 -05:00
if err = issue . loadPullRequest ( e ) ; err != nil && ! IsErrPullRequestNotExist ( err ) {
2016-08-14 05:32:24 -05:00
// It is possible pull request is not yet created.
2017-07-26 02:16:45 -05:00
return err
2016-08-14 05:32:24 -05:00
}
2016-08-26 15:40:53 -05: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-16 15:16:21 -05:00
if err = issue . loadComments ( e ) ; err != nil {
2017-12-03 18:14:26 -05:00
return err
2016-08-26 15:40:53 -05:00
}
2019-01-13 21:29:58 -05:00
if issue . isTimetrackerEnabled ( e ) {
2018-04-29 00:58:47 -05:00
if err = issue . loadTotalTimes ( e ) ; err != nil {
return err
}
}
2016-08-26 15:40:53 -05:00
2017-12-03 18:14:26 -05:00
return issue . loadReactions ( e )
2016-08-14 05:32:24 -05:00
}
2016-11-24 03:41:11 -05:00
// LoadAttributes loads the attribute of this issue.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) LoadAttributes ( ) error {
return issue . loadAttributes ( x )
2015-08-19 11:12:43 -05:00
}
2017-02-03 02:22:39 -05: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-08 22:47:24 -05:00
issue . IsRead = false
return nil
2017-02-03 02:22:39 -05:00
}
issue . IsRead = issueUser . IsRead
return nil
}
2017-03-03 09:35:42 -05:00
// APIURL returns the absolute APIURL to this issue.
func ( issue * Issue ) APIURL ( ) string {
2018-01-03 20:41:33 -05:00
return issue . Repo . APIURL ( ) + "/" + path . Join ( "issues" , fmt . Sprint ( issue . Index ) )
2017-03-03 09:35:42 -05:00
}
2016-11-24 03:41:11 -05:00
// HTMLURL returns the absolute URL to this issue.
2016-08-16 12:19:09 -05: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 06:10:39 -05: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-13 22:20:22 -05:00
// State returns string representation of issue status.
2016-11-22 06:24:39 -05:00
func ( issue * Issue ) State ( ) api . StateType {
if issue . IsClosed {
2016-11-29 03:25:47 -05:00
return api . StateClosed
2016-03-13 22:20:22 -05:00
}
2016-11-29 03:25:47 -05:00
return api . StateOpen
2016-08-14 05:32:24 -05:00
}
2016-11-22 06:24:39 -05:00
// APIFormat assumes some fields assigned with values:
2016-08-14 05:32:24 -05:00
// Required - Poster, Labels,
// Optional - Milestone, Assignee, PullRequest
func ( issue * Issue ) APIFormat ( ) * api . Issue {
2018-12-13 10:55:43 -05:00
return issue . apiFormat ( x )
}
func ( issue * Issue ) apiFormat ( e Engine ) * api . Issue {
issue . loadLabels ( e )
2016-08-14 05:32:24 -05:00
apiLabels := make ( [ ] * api . Label , len ( issue . Labels ) )
for i := range issue . Labels {
apiLabels [ i ] = issue . Labels [ i ] . APIFormat ( )
}
2018-12-13 10:55:43 -05:00
issue . loadPoster ( e )
issue . loadRepo ( e )
2016-08-14 05:32:24 -05:00
apiIssue := & api . Issue {
ID : issue . ID ,
2017-03-03 09:35:42 -05:00
URL : issue . APIURL ( ) ,
2016-08-14 05:32:24 -05:00
Index : issue . Index ,
2016-08-16 12:19:09 -05:00
Poster : issue . Poster . APIFormat ( ) ,
2016-08-14 05:32:24 -05:00
Title : issue . Title ,
Body : issue . Content ,
Labels : apiLabels ,
2016-08-16 12:19:09 -05:00
State : issue . State ( ) ,
2016-08-14 05:32:24 -05:00
Comments : issue . NumComments ,
2017-12-10 23:37:04 -05:00
Created : issue . CreatedUnix . AsTime ( ) ,
Updated : issue . UpdatedUnix . AsTime ( ) ,
2016-08-14 05:32:24 -05:00
}
ensure that the `closed_at` is set for closed (#5449)
right now the `closed_at` field for json responses is not filled during
the `APIIssue` creation for api responses.
For a closed issue you get a result like:
```json
"state":"open","comments":0,"created_at":"2018-11-29T16:39:24+01:00",
"updated_at":"2018-11-30T10:49:19+01:00","closed_at":null,
"due_date":null,"pull_request":null}
```
which has no information about the closing date. (which exists in the
db and ui)
with this PR the result changes to this:
```json
:null,"assignee":null,"assignees":null,
"state":"closed",
"comments":0,"created_at":"2018-11-29T16:43:05+01:00",
"updated_at":"2018-12-02T19:17:05+01:00",
"closed_at":"2018-12-02T19:17:05+01:00",
"due_date":null,"pull_request":null}
```
fixes: https://github.com/go-gitea/gitea/issues/5446
Signed-off-by: Roman <romaaan.git@gmail.com>
2018-12-02 15:43:01 -05:00
if issue . ClosedUnix != 0 {
apiIssue . Closed = issue . ClosedUnix . AsTimePtr ( )
}
2016-08-14 05:32:24 -05:00
if issue . Milestone != nil {
apiIssue . Milestone = issue . Milestone . APIFormat ( )
}
2018-12-13 10:55:43 -05:00
issue . loadAssignees ( e )
2018-05-09 11:29:04 -05: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 05:32:24 -05:00
}
if issue . IsPull {
2018-12-13 10:55:43 -05:00
issue . loadPullRequest ( e )
2016-08-14 05:32:24 -05:00
apiIssue . PullRequest = & api . PullRequestMeta {
HasMerged : issue . PullRequest . HasMerged ,
}
if issue . PullRequest . HasMerged {
2017-12-10 23:37:04 -05:00
apiIssue . PullRequest . Merged = issue . PullRequest . MergedUnix . AsTimePtr ( )
2016-08-14 05:32:24 -05:00
}
}
2018-05-01 14:05:28 -05:00
if issue . DeadlineUnix != 0 {
apiIssue . Deadline = issue . DeadlineUnix . AsTimePtr ( )
}
2016-08-14 05:32:24 -05:00
return apiIssue
}
// HashTag returns unique hash tag for issue.
2016-11-22 06:24:39 -05:00
func ( issue * Issue ) HashTag ( ) string {
return "issue-" + com . ToStr ( issue . ID )
2016-03-13 22:20:22 -05:00
}
2015-08-13 03:07:11 -05:00
// IsPoster returns true if given user by ID is the poster.
2016-11-22 06:24:39 -05:00
func ( issue * Issue ) IsPoster ( uid int64 ) bool {
return issue . PosterID == uid
2015-08-13 03:07:11 -05:00
}
2016-11-22 06:24:39 -05:00
func ( issue * Issue ) hasLabel ( e Engine , labelID int64 ) bool {
return hasIssueLabel ( e , issue . ID , labelID )
2015-08-10 01:42:50 -05:00
}
// HasLabel returns true if issue has been labeled by given ID.
2016-11-22 06:24:39 -05:00
func ( issue * Issue ) HasLabel ( labelID int64 ) bool {
return issue . hasLabel ( x , labelID )
2015-08-10 01:42:50 -05:00
}
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) sendLabelUpdatedWebhook ( doer * User ) {
var err error
2018-05-20 21:28:29 -05: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
}
2018-11-28 06:26:14 -05:00
mode , _ := AccessLevel ( issue . Poster , issue . Repo )
2016-08-14 05:32:24 -05:00
if issue . IsPull {
2017-07-26 02:16:45 -05:00
if err = issue . loadPullRequest ( x ) ; err != nil {
log . Error ( 4 , "loadPullRequest: %v" , err )
return
}
if err = issue . PullRequest . LoadIssue ( ) ; err != nil {
2016-08-24 14:01:30 -05:00
log . Error ( 4 , "LoadIssue: %v" , err )
return
}
2016-11-07 10:37:32 -05:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueLabelUpdated ,
2016-08-14 05:32:24 -05:00
Index : issue . Index ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2016-12-05 18:48:51 -05:00
Repository : issue . Repo . APIFormat ( AccessModeNone ) ,
2016-08-14 05:32:24 -05:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-20 21:28:29 -05: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 05:32:24 -05:00
}
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v]: %v" , issue . IsPull , err )
} else {
go HookQueue . Add ( issue . RepoID )
}
}
2017-01-30 07:46:45 -05:00
func ( issue * Issue ) addLabel ( e * xorm . Session , label * Label , doer * User ) error {
return newIssueLabel ( e , issue , label , doer )
2015-08-10 01:42:50 -05:00
}
2016-08-03 13:51:22 -05:00
// AddLabel adds a new label to the issue.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) AddLabel ( doer * User , label * Label ) error {
2017-01-30 07:46:45 -05:00
if err := NewIssueLabel ( issue , label , doer ) ; err != nil {
2015-08-14 11:42:43 -05:00
return err
}
2016-08-14 05:32:24 -05:00
issue . sendLabelUpdatedWebhook ( doer )
return nil
2015-08-10 01:42:50 -05:00
}
2017-01-30 07:46:45 -05:00
func ( issue * Issue ) addLabels ( e * xorm . Session , labels [ ] * Label , doer * User ) error {
return newIssueLabels ( e , issue , labels , doer )
2016-08-03 13:51:22 -05:00
}
// AddLabels adds a list of new labels to the issue.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) AddLabels ( doer * User , labels [ ] * Label ) error {
2017-01-30 07:46:45 -05:00
if err := NewIssueLabels ( issue , labels , doer ) ; err != nil {
2016-08-14 05:32:24 -05:00
return err
}
issue . sendLabelUpdatedWebhook ( doer )
return nil
2016-08-03 13:51:22 -05:00
}
func ( issue * Issue ) getLabels ( e Engine ) ( err error ) {
if len ( issue . Labels ) > 0 {
2014-05-24 01:31:58 -05:00
return nil
}
2016-08-03 13:51:22 -05:00
issue . Labels , err = getLabelsByIssueID ( e , issue . ID )
2015-08-10 01:42:50 -05:00
if err != nil {
return fmt . Errorf ( "getLabelsByIssueID: %v" , err )
2014-05-24 01:31:58 -05:00
}
return nil
}
2017-01-30 07:46:45 -05:00
func ( issue * Issue ) removeLabel ( e * xorm . Session , doer * User , label * Label ) error {
2017-01-31 20:31:35 -05:00
return deleteIssueLabel ( e , issue , label , doer )
2015-08-10 01:42:50 -05:00
}
// RemoveLabel removes a label from issue by given ID.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) RemoveLabel ( doer * User , label * Label ) error {
2016-12-17 06:49:17 -05:00
if err := issue . loadRepo ( x ) ; err != nil {
return err
}
2018-11-28 06:26:14 -05:00
perm , err := GetUserRepoPermission ( issue . Repo , doer )
if err != nil {
2016-12-17 06:49:17 -05:00
return err
2018-11-28 06:26:14 -05:00
}
if ! perm . CanWriteIssuesOrPulls ( issue . IsPull ) {
2016-12-17 06:49:17 -05:00
return ErrLabelNotExist { }
}
2017-01-31 20:31:35 -05:00
if err := DeleteIssueLabel ( issue , label , doer ) ; err != nil {
2016-08-14 05:32:24 -05:00
return err
}
issue . sendLabelUpdatedWebhook ( doer )
return nil
2016-08-03 13:51:22 -05:00
}
2017-01-30 07:46:45 -05:00
func ( issue * Issue ) clearLabels ( e * xorm . Session , doer * User ) ( err error ) {
2016-08-03 13:51:22 -05:00
if err = issue . getLabels ( e ) ; err != nil {
return fmt . Errorf ( "getLabels: %v" , err )
}
for i := range issue . Labels {
2017-01-30 07:46:45 -05:00
if err = issue . removeLabel ( e , doer , issue . Labels [ i ] ) ; err != nil {
2016-08-03 13:51:22 -05:00
return fmt . Errorf ( "removeLabel: %v" , err )
}
}
return nil
}
2016-11-24 03:41:11 -05:00
// ClearLabels removes all issue labels as the given user.
// Triggers appropriate WebHooks, if any.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) ClearLabels ( doer * User ) ( err error ) {
2015-08-14 11:42:43 -05:00
sess := x . NewSession ( )
2017-06-20 19:57:05 -05:00
defer sess . Close ( )
2015-08-14 11:42:43 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2016-12-17 06:49:17 -05:00
if err := issue . loadRepo ( sess ) ; err != nil {
return err
2017-07-26 02:16:45 -05:00
} else if err = issue . loadPullRequest ( sess ) ; err != nil {
return err
2016-12-17 06:49:17 -05:00
}
2018-11-28 06:26:14 -05:00
perm , err := getUserRepoPermission ( sess , issue . Repo , doer )
if err != nil {
2016-12-17 06:49:17 -05:00
return err
2018-11-28 06:26:14 -05:00
}
if ! perm . CanWriteIssuesOrPulls ( issue . IsPull ) {
2016-12-17 06:49:17 -05:00
return ErrLabelNotExist { }
}
2017-01-30 07:46:45 -05:00
if err = issue . clearLabels ( sess , doer ) ; err != nil {
2015-08-14 11:42:43 -05:00
return err
}
2016-08-14 05:32:24 -05:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
2018-05-20 21:28:29 -05:00
if err = issue . loadPoster ( x ) ; err != nil {
return fmt . Errorf ( "loadPoster: %v" , err )
}
2018-11-28 06:26:14 -05:00
mode , _ := AccessLevel ( issue . Poster , issue . Repo )
2016-08-14 05:32:24 -05:00
if issue . IsPull {
2016-08-24 14:01:30 -05:00
err = issue . PullRequest . LoadIssue ( )
if err != nil {
log . Error ( 4 , "LoadIssue: %v" , err )
return
}
2016-11-07 10:37:32 -05:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueLabelCleared ,
2016-08-14 05:32:24 -05:00
Index : issue . Index ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-20 21:28:29 -05:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 05:32:24 -05:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-20 21:28:29 -05: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 05:32:24 -05: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-14 11:42:43 -05:00
}
2017-01-30 07:46:45 -05: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-03 13:51:22 -05:00
// ReplaceLabels removes all current labels and add new labels to the issue.
2016-11-24 03:41:11 -05:00
// Triggers appropriate WebHooks, if any.
2017-01-30 07:46:45 -05:00
func ( issue * Issue ) ReplaceLabels ( labels [ ] * Label , doer * User ) ( err error ) {
2015-08-14 11:42:43 -05:00
sess := x . NewSession ( )
2017-06-20 19:57:05 -05:00
defer sess . Close ( )
2015-08-14 11:42:43 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-01-30 07:46:45 -05: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-27 20:35:55 -05: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 07:46:45 -05:00
}
}
2017-02-27 20:35:55 -05:00
toAdd = append ( toAdd , labels [ addIndex : ] ... )
toRemove = append ( toRemove , issue . Labels [ removeIndex : ] ... )
2017-01-30 07:46:45 -05:00
if len ( toAdd ) > 0 {
if err = issue . addLabels ( sess , toAdd , doer ) ; err != nil {
return fmt . Errorf ( "addLabels: %v" , err )
}
}
2017-02-27 20:35:55 -05:00
for _ , l := range toRemove {
if err = issue . removeLabel ( sess , doer , l ) ; err != nil {
return fmt . Errorf ( "removeLabel: %v" , err )
2017-01-30 07:46:45 -05:00
}
2015-08-14 11:42:43 -05:00
}
return sess . Commit ( )
2015-08-10 01:42:50 -05:00
}
2015-08-12 05:44:09 -05:00
// ReadBy sets issue to be read by given user.
2016-12-30 11:44:54 -05:00
func ( issue * Issue ) ReadBy ( userID int64 ) error {
if err := UpdateIssueUserByRead ( userID , issue . ID ) ; err != nil {
return err
}
2017-09-19 03:08:30 -05:00
return setNotificationStatusReadIfUnread ( x , userID , issue . ID )
2014-07-23 14:15:47 -05:00
}
2016-08-14 05:32:24 -05:00
func updateIssueCols ( e Engine , issue * Issue , cols ... string ) error {
2017-10-04 23:43:04 -05:00
if _ , err := e . ID ( issue . ID ) . Cols ( cols ... ) . Update ( issue ) ; err != nil {
2017-01-24 21:43:02 -05:00
return err
}
2017-12-17 06:53:02 -05:00
UpdateIssueIndexerCols ( issue . ID , cols ... )
2017-01-24 21:43:02 -05:00
return nil
2016-08-14 05:32:24 -05:00
}
// UpdateIssueCols only updates values of specific columns for given issue.
func UpdateIssueCols ( issue * Issue , cols ... string ) error {
return updateIssueCols ( x , issue , cols ... )
}
2018-12-13 10:55:43 -05:00
func ( issue * Issue ) changeStatus ( e * xorm . Session , doer * User , isClosed bool ) ( err error ) {
2016-03-05 12:58:51 -05:00
// Nothing should be performed if current status is same as target status
2016-11-22 06:24:39 -05:00
if issue . IsClosed == isClosed {
2015-08-13 03:07:11 -05:00
return nil
}
2018-07-17 16:23:58 -05:00
// Check for open dependencies
2018-10-27 09:45:24 -05:00
if isClosed && issue . Repo . isDependenciesEnabled ( e ) {
2018-07-17 16:23:58 -05:00
// 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
2018-10-27 09:45:24 -05:00
noDeps , err := issueNoDependenciesLeft ( e , issue )
2018-07-17 16:23:58 -05:00
if err != nil {
return err
}
if ! noDeps {
return ErrDependenciesLeft { issue . ID }
}
}
2016-11-22 06:24:39 -05:00
issue . IsClosed = isClosed
2018-02-18 21:39:26 -05:00
if isClosed {
issue . ClosedUnix = util . TimeStampNow ( )
} else {
issue . ClosedUnix = 0
}
2015-08-13 03:07:11 -05:00
2018-02-18 21:39:26 -05:00
if err = updateIssueCols ( e , issue , "is_closed" , "closed_unix" ) ; err != nil {
2015-08-13 03:07:11 -05:00
return err
}
2016-03-05 12:58:51 -05:00
// Update issue count of labels
2016-11-22 06:24:39 -05:00
if err = issue . getLabels ( e ) ; err != nil {
2015-08-13 03:07:11 -05:00
return err
}
2016-11-22 06:24:39 -05:00
for idx := range issue . Labels {
if issue . IsClosed {
issue . Labels [ idx ] . NumClosedIssues ++
2015-08-13 03:07:11 -05:00
} else {
2016-11-22 06:24:39 -05:00
issue . Labels [ idx ] . NumClosedIssues --
2015-08-13 03:07:11 -05:00
}
2016-11-22 06:24:39 -05:00
if err = updateLabel ( e , issue . Labels [ idx ] ) ; err != nil {
2015-08-13 03:07:11 -05:00
return err
}
}
2016-03-05 12:58:51 -05:00
// Update issue count of milestone
2016-11-22 06:24:39 -05:00
if err = changeMilestoneIssueStats ( e , issue ) ; err != nil {
2015-08-13 03:07:11 -05:00
return err
}
2016-03-05 12:58:51 -05:00
// New action comment
2018-12-13 10:55:43 -05:00
if _ , err = createStatusComment ( e , doer , issue ) ; err != nil {
2015-08-13 03:07:11 -05:00
return err
}
return nil
}
2016-03-05 12:58:51 -05:00
// ChangeStatus changes issue status to open or closed.
2018-12-13 10:55:43 -05:00
func ( issue * Issue ) ChangeStatus ( doer * User , isClosed bool ) ( err error ) {
2015-08-13 03:07:11 -05:00
sess := x . NewSession ( )
2017-06-20 19:57:05 -05:00
defer sess . Close ( )
2015-08-13 03:07:11 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2018-12-13 10:55:43 -05:00
if err = issue . loadRepo ( sess ) ; err != nil {
return err
}
if err = issue . loadPoster ( sess ) ; err != nil {
return err
}
if err = issue . changeStatus ( sess , doer , isClosed ) ; err != nil {
2015-08-13 03:07:11 -05:00
return err
}
2016-08-14 05:32:24 -05:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
2018-10-27 09:45:24 -05:00
sess . Close ( )
2016-08-14 05:32:24 -05:00
2018-11-28 06:26:14 -05:00
mode , _ := AccessLevel ( issue . Poster , issue . Repo )
2016-08-14 05:32:24 -05:00
if issue . IsPull {
2018-12-13 10:55:43 -05:00
if err = issue . loadPullRequest ( sess ) ; err != nil {
return err
}
2016-08-14 05:32:24 -05:00
// Merge pull request calls issue.changeStatus so we need to handle separately.
apiPullRequest := & api . PullRequestPayload {
Index : issue . Index ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-12-13 10:55:43 -05:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 05:32:24 -05:00
Sender : doer . APIFormat ( ) ,
}
if isClosed {
2016-11-07 10:37:32 -05:00
apiPullRequest . Action = api . HookIssueClosed
2016-08-14 05:32:24 -05:00
} else {
2016-11-29 03:25:47 -05:00
apiPullRequest . Action = api . HookIssueReOpened
2016-08-14 05:32:24 -05:00
}
2018-12-13 10:55:43 -05:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , apiPullRequest )
2018-05-20 21:28:29 -05:00
} else {
apiIssue := & api . IssuePayload {
Index : issue . Index ,
Issue : issue . APIFormat ( ) ,
2018-12-13 10:55:43 -05:00
Repository : issue . Repo . APIFormat ( mode ) ,
2018-05-20 21:28:29 -05:00
Sender : doer . APIFormat ( ) ,
}
if isClosed {
apiIssue . Action = api . HookIssueClosed
} else {
apiIssue . Action = api . HookIssueReOpened
}
2018-12-13 10:55:43 -05:00
err = PrepareWebhooks ( issue . Repo , HookEventIssues , apiIssue )
2016-08-14 05:32:24 -05:00
}
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v, is_closed: %v]: %v" , issue . IsPull , isClosed , err )
} else {
2018-12-13 10:55:43 -05:00
go HookQueue . Add ( issue . Repo . ID )
2016-08-14 05:32:24 -05:00
}
return nil
}
2016-11-24 03:41:11 -05:00
// ChangeTitle changes the title of this issue, as the given user.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) ChangeTitle ( doer * User , title string ) ( err error ) {
oldTitle := issue . Title
issue . Title = title
2017-02-05 09:36:00 -05: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 )
}
2018-12-13 10:55:43 -05:00
if err = issue . loadRepo ( sess ) ; err != nil {
return fmt . Errorf ( "loadRepo: %v" , err )
}
2017-02-05 09:36:00 -05:00
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 05:32:24 -05:00
}
2018-11-28 06:26:14 -05:00
mode , _ := AccessLevel ( issue . Poster , issue . Repo )
2016-08-14 05:32:24 -05:00
if issue . IsPull {
2018-12-13 10:55:43 -05:00
if err = issue . loadPullRequest ( sess ) ; err != nil {
return fmt . Errorf ( "loadPullRequest: %v" , err )
}
2016-08-14 05:32:24 -05:00
issue . PullRequest . Issue = issue
2016-11-07 10:37:32 -05:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueEdited ,
2016-08-14 05:32:24 -05:00
Index : issue . Index ,
Changes : & api . ChangesPayload {
Title : & api . ChangesFromPayload {
From : oldTitle ,
} ,
} ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-20 21:28:29 -05:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 05:32:24 -05:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-20 21:28:29 -05: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 05:32:24 -05:00
}
2018-05-20 21:28:29 -05:00
2016-08-14 05:32:24 -05: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 03:07:11 -05:00
}
2017-02-10 23:00:29 -05: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 03:41:11 -05:00
// ChangeContent changes issue content, as the given user.
2016-08-14 05:32:24 -05:00
func ( issue * Issue ) ChangeContent ( doer * User , content string ) ( err error ) {
oldContent := issue . Content
issue . Content = content
2018-01-03 03:34:13 -05:00
2016-08-14 05:32:24 -05:00
if err = UpdateIssueCols ( issue , "content" ) ; err != nil {
return fmt . Errorf ( "UpdateIssueCols: %v" , err )
}
2018-11-28 06:26:14 -05:00
mode , _ := AccessLevel ( issue . Poster , issue . Repo )
2016-08-14 05:32:24 -05:00
if issue . IsPull {
issue . PullRequest . Issue = issue
2016-11-07 10:37:32 -05:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueEdited ,
2016-08-14 05:32:24 -05:00
Index : issue . Index ,
Changes : & api . ChangesPayload {
Body : & api . ChangesFromPayload {
From : oldContent ,
} ,
} ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-20 21:28:29 -05:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 05:32:24 -05:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-20 21:28:29 -05: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 05:32:24 -05: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 03:34:13 -05: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 03:41:11 -05:00
// NewIssueOptions represents the options of a new issue.
2016-08-15 20:40:32 -05:00
type NewIssueOptions struct {
Repo * Repository
Issue * Issue
2017-02-28 20:08:45 -05:00
LabelIDs [ ] int64
2018-05-09 11:29:04 -05:00
AssigneeIDs [ ] int64
2016-08-15 20:40:32 -05:00
Attachments [ ] string // In UUID format.
IsPull bool
}
2016-03-13 22:20:22 -05:00
2017-01-31 21:36:08 -05:00
func newIssue ( e * xorm . Session , doer * User , opts NewIssueOptions ) ( err error ) {
2016-08-15 20:40:32 -05:00
opts . Issue . Title = strings . TrimSpace ( opts . Issue . Title )
opts . Issue . Index = opts . Repo . NextIssueIndex ( )
2016-08-16 12:19:09 -05:00
if opts . Issue . MilestoneID > 0 {
2016-08-24 18:05:56 -05:00
milestone , err := getMilestoneByRepoID ( e , opts . Issue . RepoID , opts . Issue . MilestoneID )
2016-08-16 12:19:09 -05: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-09 11:29:04 -05: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-16 12:19:09 -05:00
}
2018-05-09 11:29:04 -05: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 {
2018-11-28 06:26:14 -05:00
user , err := getUserByID ( e , assigneeID )
if err != nil {
return fmt . Errorf ( "getUserByID [user_id: %d, repo_id: %d]: %v" , assigneeID , opts . Repo . ID , err )
}
valid , err := canBeAssigned ( e , user , opts . Repo )
2018-05-09 11:29:04 -05:00
if err != nil {
2018-11-28 06:26:14 -05:00
return fmt . Errorf ( "canBeAssigned [user_id: %d, repo_id: %d]: %v" , assigneeID , opts . Repo . ID , err )
2018-05-09 11:29:04 -05:00
}
if ! valid {
return ErrUserDoesNotHaveAccessToRepo { UserID : assigneeID , RepoName : opts . Repo . Name }
}
2016-03-13 22:20:22 -05:00
}
}
2016-08-16 12:19:09 -05:00
// Milestone and assignee validation should happen before insert actual object.
2016-08-15 20:40:32 -05:00
if _ , err = e . Insert ( opts . Issue ) ; err != nil {
2014-05-07 11:09:30 -05:00
return err
2015-09-02 15:18:09 -05:00
}
2017-01-31 21:36:08 -05:00
if opts . Issue . MilestoneID > 0 {
if err = changeMilestoneAssign ( e , doer , opts . Issue , - 1 ) ; err != nil {
return err
}
}
2018-05-09 11:29:04 -05:00
// Insert the assignees
for _ , assigneeID := range opts . AssigneeIDs {
2018-08-16 06:52:51 -05:00
err = opts . Issue . changeAssignee ( e , doer , assigneeID , true )
2018-05-09 11:29:04 -05:00
if err != nil {
2017-02-03 10:09:10 -05:00
return err
}
}
2016-08-15 20:40:32 -05:00
if opts . IsPull {
_ , err = e . Exec ( "UPDATE `repository` SET num_pulls = num_pulls + 1 WHERE id = ?" , opts . Issue . RepoID )
2015-09-02 15:18:09 -05:00
} else {
2016-08-15 20:40:32 -05:00
_ , err = e . Exec ( "UPDATE `repository` SET num_issues = num_issues + 1 WHERE id = ?" , opts . Issue . RepoID )
2015-09-02 15:18:09 -05:00
}
if err != nil {
2014-05-07 11:09:30 -05:00
return err
2014-03-27 11:48:29 -05:00
}
2014-07-22 06:50:34 -05:00
2017-02-28 20:08:45 -05:00
if len ( opts . LabelIDs ) > 0 {
2016-11-21 14:08:21 -05:00
// During the session, SQLite3 driver cannot handle retrieve objects after update something.
2016-03-05 20:45:23 -05:00
// So we have to get all needed labels first.
2017-02-28 20:08:45 -05: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-05 20:45:23 -05:00
}
2015-08-14 11:42:43 -05:00
2017-01-30 07:46:45 -05:00
if err = opts . Issue . loadPoster ( e ) ; err != nil {
return err
}
2016-03-05 20:45:23 -05:00
for _ , label := range labels {
2016-08-15 20:40:32 -05:00
// Silently drop invalid labels.
if label . RepoID != opts . Repo . ID {
2016-03-13 22:20:22 -05:00
continue
}
2017-01-30 07:46:45 -05:00
if err = opts . Issue . addLabel ( e , label , opts . Issue . Poster ) ; err != nil {
2016-08-15 20:40:32 -05:00
return fmt . Errorf ( "addLabel [id: %d]: %v" , label . ID , err )
2016-03-05 20:45:23 -05:00
}
2015-08-10 03:52:08 -05:00
}
}
2016-08-15 20:40:32 -05:00
if err = newIssueUsers ( e , opts . Repo , opts . Issue ) ; err != nil {
2015-08-10 08:47:23 -05:00
return err
}
2016-08-15 20:40:32 -05:00
if len ( opts . Attachments ) > 0 {
attachments , err := getAttachmentsByUUIDs ( e , opts . Attachments )
2015-09-01 18:07:02 -05:00
if err != nil {
2016-08-15 20:40:32 -05:00
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %v" , opts . Attachments , err )
2015-09-01 18:07:02 -05:00
}
2016-08-15 20:40:32 -05:00
for i := 0 ; i < len ( attachments ) ; i ++ {
attachments [ i ] . IssueID = opts . Issue . ID
2017-10-04 23:43:04 -05:00
if _ , err = e . ID ( attachments [ i ] . ID ) . Update ( attachments [ i ] ) ; err != nil {
2016-08-15 20:40:32 -05:00
return fmt . Errorf ( "update attachment [id: %d]: %v" , attachments [ i ] . ID , err )
}
2015-08-11 10:24:40 -05:00
}
}
2016-08-15 20:40:32 -05:00
return opts . Issue . loadAttributes ( e )
2015-09-01 18:07:02 -05:00
}
// NewIssue creates new issue with labels for repository.
2018-05-09 11:29:04 -05:00
func NewIssue ( repo * Repository , issue * Issue , labelIDs [ ] int64 , assigneeIDs [ ] int64 , uuids [ ] string ) ( err error ) {
2015-09-01 18:07:02 -05:00
sess := x . NewSession ( )
2017-06-20 19:57:05 -05:00
defer sess . Close ( )
2015-09-01 18:07:02 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-01-31 21:36:08 -05:00
if err = newIssue ( sess , issue . Poster , NewIssueOptions {
2016-08-15 20:40:32 -05:00
Repo : repo ,
Issue : issue ,
2017-02-28 20:08:45 -05:00
LabelIDs : labelIDs ,
2016-08-15 20:40:32 -05:00
Attachments : uuids ,
2018-05-09 11:29:04 -05:00
AssigneeIDs : assigneeIDs ,
2016-08-15 20:40:32 -05:00
} ) ; err != nil {
2018-05-09 11:29:04 -05:00
if IsErrUserDoesNotHaveAccessToRepo ( err ) {
return err
}
2015-09-01 18:07:02 -05:00
return fmt . Errorf ( "newIssue: %v" , err )
}
2016-03-13 22:20:22 -05:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
2016-08-15 20:40:32 -05:00
if err = NotifyWatchers ( & Action {
2017-05-25 20:38:18 -05: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-15 20:40:32 -05:00
} ) ; err != nil {
2016-07-15 11:36:39 -05:00
log . Error ( 4 , "NotifyWatchers: %v" , err )
2016-08-15 20:40:32 -05:00
}
2015-08-10 10:31:59 -05:00
2018-11-28 06:26:14 -05:00
mode , _ := AccessLevel ( issue . Poster , issue . Repo )
2018-05-20 21:28:29 -05:00
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-13 22:20:22 -05:00
return nil
2014-03-20 15:04:56 -05:00
}
2018-12-13 10:55:43 -05:00
// GetIssueByIndex returns raw issue without loading attributes by index in a repository.
func GetIssueByIndex ( repoID , index int64 ) ( * Issue , error ) {
2015-08-12 04:04:23 -05:00
issue := & Issue {
RepoID : repoID ,
Index : index ,
}
2014-06-20 23:51:41 -05:00
has , err := x . Get ( issue )
2014-03-22 15:00:46 -05:00
if err != nil {
return nil , err
} else if ! has {
2015-08-12 04:04:23 -05:00
return nil , ErrIssueNotExist { 0 , repoID , index }
2014-03-22 15:00:46 -05:00
}
2016-08-26 15:40:53 -05:00
return issue , nil
}
2018-12-13 10:55:43 -05:00
// GetIssueWithAttrsByIndex returns issue by index in a repository.
func GetIssueWithAttrsByIndex ( repoID , index int64 ) ( * Issue , error ) {
issue , err := GetIssueByIndex ( repoID , index )
2016-08-26 15:40:53 -05:00
if err != nil {
return nil , err
}
2016-07-21 01:26:30 -05:00
return issue , issue . LoadAttributes ( )
2014-03-22 15:00:46 -05:00
}
2016-08-14 05:32:24 -05:00
func getIssueByID ( e Engine , id int64 ) ( * Issue , error ) {
2015-08-12 04:04:23 -05:00
issue := new ( Issue )
2017-10-04 23:43:04 -05:00
has , err := e . ID ( id ) . Get ( issue )
2014-05-07 15:51:14 -05:00
if err != nil {
return nil , err
} else if ! has {
2015-08-12 04:04:23 -05:00
return nil , ErrIssueNotExist { id , 0 , 0 }
2014-05-07 15:51:14 -05:00
}
2018-12-13 10:55:43 -05:00
return issue , nil
}
// GetIssueWithAttrsByID returns an issue with attributes by given ID.
func GetIssueWithAttrsByID ( id int64 ) ( * Issue , error ) {
issue , err := getIssueByID ( x , id )
if err != nil {
return nil , err
}
return issue , issue . loadAttributes ( x )
2014-05-07 15:51:14 -05:00
}
2016-08-14 05:32:24 -05:00
// GetIssueByID returns an issue by given ID.
func GetIssueByID ( id int64 ) ( * Issue , error ) {
return getIssueByID ( x , id )
}
2017-03-14 20:10:35 -05: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 03:41:11 -05:00
// IssuesOptions represents options of an issue.
2015-09-02 15:18:09 -05:00
type IssuesOptions struct {
2017-12-25 18:25:16 -05:00
RepoIDs [ ] int64 // include all repos if empty
2016-12-24 05:33:21 -05:00
AssigneeID int64
2015-09-02 15:18:09 -05:00
PosterID int64
2016-12-24 05:33:21 -05:00
MentionedID int64
2015-09-02 15:18:09 -05:00
MilestoneID int64
Page int
2017-08-03 00:09:16 -05:00
PageSize int
2017-01-24 21:43:02 -05:00
IsClosed util . OptionalBool
IsPull util . OptionalBool
2019-01-22 23:10:38 -05:00
LabelIDs [ ] int64
2015-09-02 15:18:09 -05:00
SortType string
2017-01-24 21:43:02 -05:00
IssueIDs [ ] int64
2015-09-02 15:18:09 -05:00
}
2017-01-01 13:15:09 -05: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 00:09:16 -05:00
func ( opts * IssuesOptions ) setupSession ( sess * xorm . Session ) error {
if opts . Page >= 0 && opts . PageSize > 0 {
2017-01-24 21:43:02 -05:00
var start int
if opts . Page == 0 {
start = 0
} else {
2017-08-03 00:09:16 -05:00
start = ( opts . Page - 1 ) * opts . PageSize
2017-01-24 21:43:02 -05:00
}
2017-08-03 00:09:16 -05:00
sess . Limit ( opts . PageSize , start )
2016-03-13 22:20:22 -05:00
}
2017-01-24 21:43:02 -05:00
if len ( opts . IssueIDs ) > 0 {
sess . In ( "issue.id" , opts . IssueIDs )
}
2014-03-22 15:00:46 -05:00
2017-12-25 18:25:16 -05:00
if len ( opts . RepoIDs ) > 0 {
2015-09-01 05:31:47 -05:00
// In case repository IDs are provided but actually no repository has issue.
2016-11-12 07:06:33 -05:00
sess . In ( "issue.repo_id" , opts . RepoIDs )
2014-03-22 15:00:46 -05:00
}
2017-01-24 21:43:02 -05:00
switch opts . IsClosed {
case util . OptionalBoolTrue :
2017-01-25 03:28:03 -05:00
sess . And ( "issue.is_closed=?" , true )
2017-01-24 21:43:02 -05:00
case util . OptionalBoolFalse :
2017-01-25 03:28:03 -05:00
sess . And ( "issue.is_closed=?" , false )
2017-01-24 21:43:02 -05:00
}
2014-03-22 15:00:46 -05:00
2015-09-02 15:18:09 -05:00
if opts . AssigneeID > 0 {
2018-05-09 11:29:04 -05:00
sess . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . AssigneeID )
2016-12-24 05:33:21 -05:00
}
if opts . PosterID > 0 {
2016-07-16 20:18:35 -05:00
sess . And ( "issue.poster_id=?" , opts . PosterID )
2014-03-22 12:50:50 -05:00
}
2016-12-24 05:33:21 -05: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-02 15:18:09 -05:00
if opts . MilestoneID > 0 {
2016-07-16 20:18:35 -05:00
sess . And ( "issue.milestone_id=?" , opts . MilestoneID )
2014-03-22 12:50:50 -05:00
}
2017-01-24 21:43:02 -05:00
switch opts . IsPull {
case util . OptionalBoolTrue :
2017-01-28 11:01:07 -05:00
sess . And ( "issue.is_pull=?" , true )
2017-01-24 21:43:02 -05:00
case util . OptionalBoolFalse :
2017-01-28 11:01:07 -05:00
sess . And ( "issue.is_pull=?" , false )
2017-01-24 21:43:02 -05:00
}
2015-09-02 15:18:09 -05:00
2019-01-22 23:10:38 -05:00
if opts . LabelIDs != nil {
for i , labelID := range opts . LabelIDs {
sess . Join ( "INNER" , fmt . Sprintf ( "issue_label il%d" , i ) ,
fmt . Sprintf ( "issue.id = il%[1]d.issue_id AND il%[1]d.label_id = %[2]d" , i , labelID ) )
2016-04-25 23:22:03 -05:00
}
2015-08-10 08:47:23 -05:00
}
2017-08-03 00:09:16 -05: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 08:47:23 -05:00
2016-07-23 11:23:54 -05:00
issues := make ( [ ] * Issue , 0 , setting . UI . IssuePagingNum )
2016-08-26 15:40:53 -05:00
if err := sess . Find ( & issues ) ; err != nil {
return nil , fmt . Errorf ( "Find: %v" , err )
}
2017-02-22 09:03:59 -05:00
if err := IssueList ( issues ) . LoadAttributes ( ) ; err != nil {
return nil , fmt . Errorf ( "LoadAttributes: %v" , err )
2016-08-26 15:40:53 -05:00
}
return issues , nil
2014-03-22 12:50:50 -05:00
}
2017-03-15 20:34:24 -05:00
// GetParticipantsByIssueID returns all users who are participated in comments of an issue.
func GetParticipantsByIssueID ( issueID int64 ) ( [ ] * User , error ) {
2017-08-29 23:31:33 -05:00
return getParticipantsByIssueID ( x , issueID )
}
func getParticipantsByIssueID ( e Engine , issueID int64 ) ( [ ] * User , error ) {
2017-03-15 20:34:24 -05:00
userIDs := make ( [ ] int64 , 0 , 5 )
2017-08-29 23:31:33 -05:00
if err := e . Table ( "comment" ) . Cols ( "poster_id" ) .
2017-09-15 19:18:25 -05:00
Where ( "`comment`.issue_id = ?" , issueID ) .
And ( "`comment`.type = ?" , CommentTypeComment ) .
And ( "`user`.is_active = ?" , true ) .
And ( "`user`.prohibit_login = ?" , false ) .
2018-07-19 21:10:17 -05:00
Join ( "INNER" , "`user`" , "`user`.id = `comment`.poster_id" ) .
2017-03-15 20:34:24 -05: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-29 23:31:33 -05:00
return users , e . In ( "id" , userIDs ) . Find ( & users )
2017-03-15 20:34:24 -05:00
}
2016-07-15 11:36:39 -05:00
// UpdateIssueMentions extracts mentioned people from content and
// updates issue-user relations for them.
2016-12-22 04:00:39 -05:00
func UpdateIssueMentions ( e Engine , issueID int64 , mentions [ ] string ) error {
2016-07-15 11:36:39 -05:00
if len ( mentions ) == 0 {
return nil
2015-12-21 07:24:11 -05:00
}
2016-07-15 11:36:39 -05:00
for i := range mentions {
mentions [ i ] = strings . ToLower ( mentions [ i ] )
}
users := make ( [ ] * User , 0 , len ( mentions ) )
2016-12-22 04:00:39 -05:00
if err := e . In ( "lower_name" , mentions ) . Asc ( "lower_name" ) . Find ( & users ) ; err != nil {
2016-07-15 11:36:39 -05:00
return fmt . Errorf ( "find mentioned users: %v" , err )
2015-12-21 07:24:11 -05:00
}
2016-07-15 11:36:39 -05:00
ids := make ( [ ] int64 , 0 , len ( mentions ) )
2015-12-21 07:24:11 -05:00
for _ , user := range users {
2016-07-23 12:08:22 -05:00
ids = append ( ids , user . ID )
2016-07-15 11:36:39 -05:00
if ! user . IsOrganization ( ) || user . NumMembers == 0 {
2015-12-21 07:24:11 -05:00
continue
}
2016-07-15 11:36:39 -05:00
memberIDs := make ( [ ] int64 , 0 , user . NumMembers )
2019-01-04 16:51:27 -05:00
orgUsers , err := getOrgUsersByOrgID ( e , user . ID )
2015-12-21 07:24:11 -05:00
if err != nil {
2016-07-23 12:08:22 -05:00
return fmt . Errorf ( "GetOrgUsersByOrgID [%d]: %v" , user . ID , err )
2015-12-21 07:24:11 -05:00
}
for _ , orgUser := range orgUsers {
2016-07-15 11:36:39 -05:00
memberIDs = append ( memberIDs , orgUser . ID )
2015-12-21 07:24:11 -05:00
}
2016-07-15 11:36:39 -05:00
ids = append ( ids , memberIDs ... )
2015-12-21 07:24:11 -05:00
}
2016-12-22 04:00:39 -05:00
if err := UpdateIssueUsersByMentions ( e , issueID , ids ) ; err != nil {
2016-07-15 11:36:39 -05:00
return fmt . Errorf ( "UpdateIssueUsersByMentions: %v" , err )
2015-12-21 07:24:11 -05:00
}
return nil
}
2014-05-07 11:09:30 -05:00
// IssueStats represents issue statistic information.
type IssueStats struct {
OpenCount , ClosedCount int64
2017-02-14 09:15:18 -05:00
YourRepositoriesCount int64
2014-05-07 11:09:30 -05:00
AssignCount int64
CreateCount int64
MentionCount int64
}
// Filter modes.
const (
2016-11-07 11:24:59 -05:00
FilterModeAll = iota
FilterModeAssign
FilterModeCreate
FilterModeMention
2014-05-07 11:09:30 -05:00
)
2015-08-10 08:47:23 -05: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 03:41:11 -05:00
// IssueStatsOptions contains parameters accepted by GetIssueStats.
2015-09-02 15:18:09 -05:00
type IssueStatsOptions struct {
RepoID int64
2016-04-25 23:07:49 -05:00
Labels string
2015-09-02 15:18:09 -05:00
MilestoneID int64
AssigneeID int64
2016-12-24 05:33:21 -05:00
MentionedID int64
PosterID int64
2018-11-28 20:46:30 -05:00
IsPull util . OptionalBool
2017-01-24 21:43:02 -05:00
IssueIDs [ ] int64
2015-09-02 15:18:09 -05:00
}
2014-05-07 15:51:14 -05:00
// GetIssueStats returns issue statistic information by given conditions.
2017-01-24 21:43:02 -05:00
func GetIssueStats ( opts * IssueStatsOptions ) ( * IssueStats , error ) {
2014-05-07 11:09:30 -05:00
stats := & IssueStats { }
2015-07-24 13:52:25 -05:00
2016-04-25 23:07:49 -05:00
countSession := func ( opts * IssueStatsOptions ) * xorm . Session {
2016-11-10 10:16:32 -05:00
sess := x .
2018-11-28 20:46:30 -05:00
Where ( "issue.repo_id = ?" , opts . RepoID )
2015-08-10 08:47:23 -05:00
2017-01-24 21:43:02 -05:00
if len ( opts . IssueIDs ) > 0 {
sess . In ( "issue.id" , opts . IssueIDs )
}
2016-05-06 14:40:41 -05:00
if len ( opts . Labels ) > 0 && opts . Labels != "0" {
2016-12-22 03:58:04 -05:00
labelIDs , err := base . StringsToInt64s ( strings . Split ( opts . Labels , "," ) )
if err != nil {
log . Warn ( "Malformed Labels argument: %s" , opts . Labels )
2019-01-22 23:10:38 -05:00
} else {
for i , labelID := range labelIDs {
sess . Join ( "INNER" , fmt . Sprintf ( "issue_label il%d" , i ) ,
fmt . Sprintf ( "issue.id = il%[1]d.issue_id AND il%[1]d.label_id = %[2]d" , i , labelID ) )
}
2016-04-25 23:22:03 -05:00
}
2016-04-25 23:07:49 -05:00
}
if opts . MilestoneID > 0 {
sess . And ( "issue.milestone_id = ?" , opts . MilestoneID )
}
if opts . AssigneeID > 0 {
2018-05-09 11:29:04 -05:00
sess . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . AssigneeID )
2016-04-25 23:07:49 -05:00
}
2016-12-24 05:33:21 -05:00
if opts . PosterID > 0 {
2017-06-14 22:09:03 -05:00
sess . And ( "issue.poster_id = ?" , opts . PosterID )
2016-12-24 05:33:21 -05:00
}
2015-07-24 13:52:25 -05:00
2016-12-24 05:33:21 -05:00
if opts . MentionedID > 0 {
sess . Join ( "INNER" , "issue_user" , "issue.id = issue_user.issue_id" ) .
2016-12-30 02:26:05 -05:00
And ( "issue_user.uid = ?" , opts . MentionedID ) .
And ( "issue_user.is_mentioned = ?" , true )
2016-12-24 05:33:21 -05:00
}
2016-04-25 23:07:49 -05:00
2018-11-28 20:46:30 -05:00
switch opts . IsPull {
case util . OptionalBoolTrue :
sess . And ( "issue.is_pull=?" , true )
case util . OptionalBoolFalse :
sess . And ( "issue.is_pull=?" , false )
}
2016-12-24 05:33:21 -05:00
return sess
2015-07-24 13:52:25 -05:00
}
2016-12-24 05:33:21 -05:00
2017-01-24 21:43:02 -05:00
var err error
2017-06-14 22:09:03 -05:00
stats . OpenCount , err = countSession ( opts ) .
And ( "issue.is_closed = ?" , false ) .
Count ( new ( Issue ) )
if err != nil {
return stats , err
2017-01-24 21:43:02 -05:00
}
2017-06-14 22:09:03 -05:00
stats . ClosedCount , err = countSession ( opts ) .
And ( "issue.is_closed = ?" , true ) .
Count ( new ( Issue ) )
2017-02-14 09:15:18 -05:00
return stats , err
2014-05-07 11:09:30 -05:00
}
2017-12-25 18:25:16 -05:00
// UserIssueStatsOptions contains parameters accepted by GetUserIssueStats.
type UserIssueStatsOptions struct {
UserID int64
RepoID int64
UserRepoIDs [ ] int64
FilterMode int
IsPull bool
IsClosed bool
}
2014-05-07 15:51:14 -05:00
// GetUserIssueStats returns issue statistic information for dashboard by given conditions.
2017-12-25 18:25:16 -05:00
func GetUserIssueStats ( opts UserIssueStatsOptions ) ( * IssueStats , error ) {
var err error
2014-05-07 11:09:30 -05:00
stats := & IssueStats { }
2015-08-25 09:58:34 -05:00
2017-12-25 18:25:16 -05: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-02 15:18:09 -05:00
}
2017-12-25 18:25:16 -05:00
switch opts . FilterMode {
2017-02-14 09:15:18 -05:00
case FilterModeAll :
2017-12-25 18:25:16 -05:00
stats . OpenCount , err = x . Where ( cond ) . And ( "is_closed = ?" , false ) .
And ( builder . In ( "issue.repo_id" , opts . UserRepoIDs ) ) .
2017-02-14 09:15:18 -05:00
Count ( new ( Issue ) )
2017-12-25 18:25:16 -05: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 09:15:18 -05:00
Count ( new ( Issue ) )
2017-12-25 18:25:16 -05:00
if err != nil {
return nil , err
}
2016-11-07 11:24:59 -05:00
case FilterModeAssign :
2017-12-25 18:25:16 -05:00
stats . OpenCount , err = x . Where ( cond ) . And ( "is_closed = ?" , false ) .
2018-05-09 11:29:04 -05:00
Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . UserID ) .
2017-02-14 09:15:18 -05:00
Count ( new ( Issue ) )
2017-12-25 18:25:16 -05:00
if err != nil {
return nil , err
}
stats . ClosedCount , err = x . Where ( cond ) . And ( "is_closed = ?" , true ) .
2018-05-09 11:29:04 -05:00
Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . UserID ) .
2017-02-14 09:15:18 -05:00
Count ( new ( Issue ) )
2017-12-25 18:25:16 -05:00
if err != nil {
return nil , err
}
2016-11-07 11:24:59 -05:00
case FilterModeCreate :
2017-12-25 18:25:16 -05:00
stats . OpenCount , err = x . Where ( cond ) . And ( "is_closed = ?" , false ) .
And ( "poster_id = ?" , opts . UserID ) .
2017-02-14 09:15:18 -05:00
Count ( new ( Issue ) )
2017-12-25 18:25:16 -05: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 09:15:18 -05:00
Count ( new ( Issue ) )
2017-12-25 18:25:16 -05: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-09 11:29:04 -05:00
Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . UserID ) .
2017-12-25 18:25:16 -05: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 09:58:34 -05:00
}
2017-12-25 18:25:16 -05:00
return stats , nil
2014-05-07 11:09:30 -05:00
}
2015-08-25 09:58:34 -05:00
// GetRepoIssueStats returns number of open and closed repository issues by given filter mode.
2015-09-02 15:18:09 -05:00
func GetRepoIssueStats ( repoID , uid int64 , filterMode int , isPull bool ) ( numOpen int64 , numClosed int64 ) {
2016-04-25 23:07:49 -05:00
countSession := func ( isClosed , isPull bool , repoID int64 ) * xorm . Session {
2016-11-10 10:16:32 -05:00
sess := x .
2017-02-09 04:59:57 -05:00
Where ( "is_closed = ?" , isClosed ) .
2016-04-25 23:22:03 -05:00
And ( "is_pull = ?" , isPull ) .
And ( "repo_id = ?" , repoID )
2015-09-02 15:18:09 -05:00
2016-04-25 23:07:49 -05:00
return sess
2015-09-02 15:18:09 -05:00
}
2016-04-25 23:07:49 -05:00
openCountSession := countSession ( false , isPull , repoID )
closedCountSession := countSession ( true , isPull , repoID )
2015-08-25 09:58:34 -05:00
switch filterMode {
2016-11-07 11:24:59 -05:00
case FilterModeAssign :
2018-05-09 11:29:04 -05: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-07 11:24:59 -05:00
case FilterModeCreate :
2016-04-25 23:07:49 -05:00
openCountSession . And ( "poster_id = ?" , uid )
closedCountSession . And ( "poster_id = ?" , uid )
2015-08-25 09:58:34 -05:00
}
2017-02-14 09:15:18 -05:00
openResult , _ := openCountSession . Count ( new ( Issue ) )
closedResult , _ := closedCountSession . Count ( new ( Issue ) )
2016-04-25 23:07:49 -05:00
return openResult , closedResult
2015-08-25 09:58:34 -05:00
}
2015-08-10 05:57:57 -05:00
func updateIssue ( e Engine , issue * Issue ) error {
2017-10-04 23:43:04 -05:00
_ , err := e . ID ( issue . ID ) . AllCols ( ) . Update ( issue )
2017-01-24 21:43:02 -05:00
if err != nil {
return err
}
return nil
2015-08-10 05:57:57 -05:00
}
2015-10-24 02:36:47 -05:00
// UpdateIssue updates all fields of given issue.
func UpdateIssue ( issue * Issue ) error {
return updateIssue ( x , issue )
}
2018-05-01 14:05:28 -05: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-17 16:23:58 -05: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 )
}