2014-03-20 16:04:56 -04:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2020-01-01 17:51:10 -05:00
// Copyright 2020 The Gitea Authors. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2014-03-20 16:04:56 -04:00
2022-06-13 05:37:59 -04:00
package issues
2014-03-20 16:04:56 -04:00
2014-03-22 13:50:50 -04:00
import (
2021-09-23 11:45:36 -04:00
"context"
2015-08-10 02:42:50 -04:00
"fmt"
2018-01-03 03:34:13 -05:00
"regexp"
2017-01-30 07:46:45 -05:00
"sort"
2014-03-22 13:50:50 -04:00
"strings"
2014-05-07 16:51:14 -04:00
2021-09-19 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2022-03-29 02:29:02 -04:00
"code.gitea.io/gitea/models/organization"
2021-11-28 06:58:28 -05:00
"code.gitea.io/gitea/models/perm"
2022-05-11 06:09:36 -04:00
access_model "code.gitea.io/gitea/models/perm/access"
2022-03-29 10:16:31 -04:00
project_model "code.gitea.io/gitea/models/project"
2021-11-19 08:39:57 -05:00
repo_model "code.gitea.io/gitea/models/repo"
2022-10-16 19:29:26 -04:00
system_model "code.gitea.io/gitea/models/system"
2021-11-09 14:57:58 -05:00
"code.gitea.io/gitea/models/unit"
2021-11-24 04:49:20 -05:00
user_model "code.gitea.io/gitea/models/user"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/base"
2021-12-02 02:28:08 -05:00
"code.gitea.io/gitea/modules/git"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/log"
2021-01-02 12:04:02 -05:00
"code.gitea.io/gitea/modules/references"
2019-05-11 06:21:34 -04:00
api "code.gitea.io/gitea/modules/structs"
2019-08-15 10:46:21 -04:00
"code.gitea.io/gitea/modules/timeutil"
2017-01-24 21:43:02 -05:00
"code.gitea.io/gitea/modules/util"
2017-12-25 18:25:16 -05:00
2019-06-23 11:22:43 -04:00
"xorm.io/builder"
2019-10-17 05:26:49 -04:00
"xorm.io/xorm"
2014-03-22 13:50:50 -04:00
)
2022-06-13 05:37:59 -04:00
// ErrIssueNotExist represents a "IssueNotExist" kind of error.
type ErrIssueNotExist struct {
ID int64
RepoID int64
Index int64
}
// IsErrIssueNotExist checks if an error is a ErrIssueNotExist.
func IsErrIssueNotExist ( err error ) bool {
_ , ok := err . ( ErrIssueNotExist )
return ok
}
func ( err ErrIssueNotExist ) Error ( ) string {
return fmt . Sprintf ( "issue does not exist [id: %d, repo_id: %d, index: %d]" , err . ID , err . RepoID , err . Index )
}
2022-10-18 01:50:37 -04:00
func ( err ErrIssueNotExist ) Unwrap ( ) error {
return util . ErrNotExist
}
2022-06-13 05:37:59 -04:00
// ErrIssueIsClosed represents a "IssueIsClosed" kind of error.
type ErrIssueIsClosed struct {
ID int64
RepoID int64
Index int64
}
// IsErrIssueIsClosed checks if an error is a ErrIssueNotExist.
func IsErrIssueIsClosed ( err error ) bool {
_ , ok := err . ( ErrIssueIsClosed )
return ok
}
func ( err ErrIssueIsClosed ) Error ( ) string {
return fmt . Sprintf ( "issue is closed [id: %d, repo_id: %d, index: %d]" , err . ID , err . RepoID , err . Index )
}
// ErrNewIssueInsert is used when the INSERT statement in newIssue fails
type ErrNewIssueInsert struct {
OriginalError error
}
// IsErrNewIssueInsert checks if an error is a ErrNewIssueInsert.
func IsErrNewIssueInsert ( err error ) bool {
_ , ok := err . ( ErrNewIssueInsert )
return ok
}
func ( err ErrNewIssueInsert ) Error ( ) string {
return err . OriginalError . Error ( )
}
// ErrIssueWasClosed is used when close a closed issue
type ErrIssueWasClosed struct {
ID int64
Index int64
}
// IsErrIssueWasClosed checks if an error is a ErrIssueWasClosed.
func IsErrIssueWasClosed ( err error ) bool {
_ , ok := err . ( ErrIssueWasClosed )
return ok
}
func ( err ErrIssueWasClosed ) Error ( ) string {
return fmt . Sprintf ( "Issue [%d] %d was already closed" , err . ID , err . Index )
}
2014-03-22 13:50:50 -04:00
// Issue represents an issue or pull request of repository.
2014-03-20 16:04:56 -04:00
type Issue struct {
2021-12-09 20:27:50 -05:00
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"INDEX UNIQUE(repo_index)" `
Repo * repo_model . Repository ` xorm:"-" `
Index int64 ` xorm:"UNIQUE(repo_index)" ` // Index in one repository.
PosterID int64 ` xorm:"INDEX" `
Poster * user_model . User ` xorm:"-" `
2019-07-07 22:14:12 -04:00
OriginalAuthor string
2022-06-13 05:37:59 -04:00
OriginalAuthorID int64 ` xorm:"index" `
Title string ` xorm:"name" `
Content string ` xorm:"LONGTEXT" `
RenderedContent string ` xorm:"-" `
Labels [ ] * Label ` xorm:"-" `
MilestoneID int64 ` xorm:"INDEX" `
Milestone * Milestone ` xorm:"-" `
Project * project_model . Project ` xorm:"-" `
2019-07-07 22:14:12 -04:00
Priority int
2021-11-24 04:49:20 -05:00
AssigneeID int64 ` xorm:"-" `
Assignee * user_model . User ` xorm:"-" `
IsClosed bool ` xorm:"INDEX" `
IsRead bool ` xorm:"-" `
IsPull bool ` xorm:"INDEX" ` // Indicates whether is a pull request or not.
PullRequest * PullRequest ` xorm:"-" `
2019-07-07 22:14:12 -04:00
NumComments int
Ref string
2016-03-09 19:53:30 -05:00
2019-08-15 10:46:21 -04:00
DeadlineUnix timeutil . TimeStamp ` xorm:"INDEX" `
2018-05-01 15:05:28 -04:00
2019-08-15 10:46:21 -04:00
CreatedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"INDEX updated" `
ClosedUnix timeutil . TimeStamp ` xorm:"INDEX" `
2015-08-12 05:04:23 -04:00
2022-12-23 06:35:43 -05:00
Attachments [ ] * repo_model . Attachment ` xorm:"-" `
Comments [ ] * Comment ` xorm:"-" `
Reactions ReactionList ` xorm:"-" `
TotalTrackedTime int64 ` xorm:"-" `
Assignees [ ] * user_model . User ` xorm:"-" `
2019-02-18 15:55:04 -05:00
// IsLocked limits commenting abilities to users on an issue
// with write access
IsLocked bool ` xorm:"NOT NULL DEFAULT false" `
2020-09-10 14:09:14 -04:00
// For view issue page.
2021-11-11 01:29:30 -05:00
ShowRole RoleDescriptor ` xorm:"-" `
2015-08-12 05:04:23 -04:00
}
2018-01-03 03:34:13 -05:00
var (
issueTasksPat * regexp . Regexp
issueTasksDonePat * regexp . Regexp
)
2021-03-14 14:52:12 -04:00
const (
2021-06-13 22:22:55 -04:00
issueTasksRegexpStr = ` (^\s*[-*]\s\[[\sxX]\]\s.)|(\n\s*[-*]\s\[[\sxX]\]\s.) `
issueTasksDoneRegexpStr = ` (^\s*[-*]\s\[[xX]\]\s.)|(\n\s*[-*]\s\[[xX]\]\s.) `
2021-03-14 14:52:12 -04:00
)
2018-01-03 03:34:13 -05:00
2021-09-19 07:49:59 -04:00
// IssueIndex represents the issue index table
type IssueIndex db . ResourceIndex
2018-01-03 03:34:13 -05:00
func init ( ) {
issueTasksPat = regexp . MustCompile ( issueTasksRegexpStr )
issueTasksDonePat = regexp . MustCompile ( issueTasksDoneRegexpStr )
2021-09-19 07:49:59 -04:00
db . RegisterModel ( new ( Issue ) )
db . RegisterModel ( new ( IssueIndex ) )
2018-01-03 03:34:13 -05:00
}
2022-06-13 05:37:59 -04:00
// LoadTotalTimes load total tracked time
func ( issue * Issue ) LoadTotalTimes ( ctx context . Context ) ( err error ) {
2018-04-29 01:58:47 -04:00
opts := FindTrackedTimesOptions { IssueID : issue . ID }
2022-05-20 10:08:52 -04:00
issue . TotalTrackedTime , err = opts . toSession ( db . GetEngine ( ctx ) ) . SumInt ( & TrackedTime { } , "time" )
2018-04-29 01:58:47 -04:00
if err != nil {
return err
}
return nil
}
2018-05-01 15:05:28 -04:00
// IsOverdue checks if the issue is overdue
func ( issue * Issue ) IsOverdue ( ) bool {
2021-03-07 20:55:57 -05:00
if issue . IsClosed {
return issue . ClosedUnix >= issue . DeadlineUnix
}
2019-08-15 10:46:21 -04:00
return timeutil . TimeStampNow ( ) >= issue . DeadlineUnix
2018-05-01 15:05:28 -04:00
}
2018-12-13 10:55:43 -05:00
// LoadRepo loads issue's repository
2022-04-08 05:11:15 -04:00
func ( issue * Issue ) LoadRepo ( ctx context . Context ) ( err error ) {
2016-08-26 16:40:53 -04:00
if issue . Repo == nil {
2022-12-02 21:48:26 -05:00
issue . Repo , err = repo_model . GetRepositoryByID ( ctx , issue . RepoID )
2016-03-13 23:20:22 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getRepositoryByID [%d]: %w" , issue . RepoID , err )
2016-03-13 23:20:22 -04:00
}
2016-08-26 16:40:53 -04:00
}
2016-12-17 06:49:17 -05:00
return nil
}
2018-04-29 01:58:47 -04:00
// IsTimetrackerEnabled returns true if the repo enables timetracking
2022-12-09 21:46:31 -05:00
func ( issue * Issue ) IsTimetrackerEnabled ( ctx context . Context ) bool {
2022-04-08 05:11:15 -04:00
if err := issue . LoadRepo ( ctx ) ; err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( fmt . Sprintf ( "loadRepo: %v" , err ) )
2018-04-29 01:58:47 -04:00
return false
}
2022-12-09 21:46:31 -05:00
return issue . Repo . IsTimetrackerEnabled ( ctx )
2018-04-29 01:58:47 -04:00
}
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" )
}
2022-05-20 10:08:52 -04:00
pr , err = GetPullRequestByIssueID ( db . DefaultContext , issue . ID )
2018-10-18 07:23:05 -04:00
if err != nil {
return nil , err
}
pr . Issue = issue
2022-06-20 06:02:49 -04:00
return pr , err
2017-01-28 11:01:07 -05:00
}
2020-02-28 21:49:50 -05:00
// LoadLabels loads labels
2022-04-28 07:48:48 -04:00
func ( issue * Issue ) LoadLabels ( ctx context . Context ) ( err error ) {
2017-01-30 07:46:45 -05:00
if issue . Labels == nil {
2022-05-20 10:08:52 -04:00
issue . Labels , err = GetLabelsByIssueID ( ctx , issue . ID )
2017-01-30 07:46:45 -05:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getLabelsByIssueID [%d]: %w" , issue . ID , err )
2017-01-30 07:46:45 -05:00
}
2016-12-17 06:49:17 -05:00
}
2017-01-30 07:46:45 -05:00
return nil
}
2016-03-13 23:20:22 -04:00
2018-12-13 10:55:43 -05:00
// LoadPoster loads poster
2022-11-19 03:12:33 -05:00
func ( issue * Issue ) LoadPoster ( ctx context . Context ) ( err error ) {
2016-08-26 16:40:53 -04:00
if issue . Poster == nil {
Implement actions (#21937)
Close #13539.
Co-authored by: @lunny @appleboy @fuxiaohei and others.
Related projects:
- https://gitea.com/gitea/actions-proto-def
- https://gitea.com/gitea/actions-proto-go
- https://gitea.com/gitea/act
- https://gitea.com/gitea/act_runner
### Summary
The target of this PR is to bring a basic implementation of "Actions",
an internal CI/CD system of Gitea. That means even though it has been
merged, the state of the feature is **EXPERIMENTAL**, and please note
that:
- It is disabled by default;
- It shouldn't be used in a production environment currently;
- It shouldn't be used in a public Gitea instance currently;
- Breaking changes may be made before it's stable.
**Please comment on #13539 if you have any different product design
ideas**, all decisions reached there will be adopted here. But in this
PR, we don't talk about **naming, feature-creep or alternatives**.
### ⚠️ Breaking
`gitea-actions` will become a reserved user name. If a user with the
name already exists in the database, it is recommended to rename it.
### Some important reviews
- What is `DEFAULT_ACTIONS_URL` in `app.ini` for?
- https://github.com/go-gitea/gitea/pull/21937#discussion_r1055954954
- Why the api for runners is not under the normal `/api/v1` prefix?
- https://github.com/go-gitea/gitea/pull/21937#discussion_r1061173592
- Why DBFS?
- https://github.com/go-gitea/gitea/pull/21937#discussion_r1061301178
- Why ignore events triggered by `gitea-actions` bot?
- https://github.com/go-gitea/gitea/pull/21937#discussion_r1063254103
- Why there's no permission control for actions?
- https://github.com/go-gitea/gitea/pull/21937#discussion_r1090229868
### What it looks like
<details>
#### Manage runners
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205870657-c72f590e-2e08-4cd4-be7f-2e0abb299bbf.png">
#### List runs
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205872794-50fde990-2b45-48c1-a178-908e4ec5b627.png">
#### View logs
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205872501-9b7b9000-9542-4991-8f55-18ccdada77c3.png">
</details>
### How to try it
<details>
#### 1. Start Gitea
Clone this branch and [install from
source](https://docs.gitea.io/en-us/install-from-source).
Add additional configurations in `app.ini` to enable Actions:
```ini
[actions]
ENABLED = true
```
Start it.
If all is well, you'll see the management page of runners:
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205877365-8e30a780-9b10-4154-b3e8-ee6c3cb35a59.png">
#### 2. Start runner
Clone the [act_runner](https://gitea.com/gitea/act_runner), and follow
the
[README](https://gitea.com/gitea/act_runner/src/branch/main/README.md)
to start it.
If all is well, you'll see a new runner has been added:
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205878000-216f5937-e696-470d-b66c-8473987d91c3.png">
#### 3. Enable actions for a repo
Create a new repo or open an existing one, check the `Actions` checkbox
in settings and submit.
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205879705-53e09208-73c0-4b3e-a123-2dcf9aba4b9c.png">
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205879383-23f3d08f-1a85-41dd-a8b3-54e2ee6453e8.png">
If all is well, you'll see a new tab "Actions":
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205881648-a8072d8c-5803-4d76-b8a8-9b2fb49516c1.png">
#### 4. Upload workflow files
Upload some workflow files to `.gitea/workflows/xxx.yaml`, you can
follow the [quickstart](https://docs.github.com/en/actions/quickstart)
of GitHub Actions. Yes, Gitea Actions is compatible with GitHub Actions
in most cases, you can use the same demo:
```yaml
name: GitHub Actions Demo
run-name: ${{ github.actor }} is testing out GitHub Actions 🚀
on: [push]
jobs:
Explore-GitHub-Actions:
runs-on: ubuntu-latest
steps:
- run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
- run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
- run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
- name: Check out repository code
uses: actions/checkout@v3
- run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
- run: echo "🖥️ The workflow is now ready to test your code on the runner."
- name: List files in the repository
run: |
ls ${{ github.workspace }}
- run: echo "🍏 This job's status is ${{ job.status }}."
```
If all is well, you'll see a new run in `Actions` tab:
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205884473-79a874bc-171b-4aaf-acd5-0241a45c3b53.png">
#### 5. Check the logs of jobs
Click a run and you'll see the logs:
<img width="1792" alt="image"
src="https://user-images.githubusercontent.com/9418365/205884800-994b0374-67f7-48ff-be9a-4c53f3141547.png">
#### 6. Go on
You can try more examples in [the
documents](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions)
of GitHub Actions, then you might find a lot of bugs.
Come on, PRs are welcome.
</details>
See also: [Feature Preview: Gitea
Actions](https://blog.gitea.io/2022/12/feature-preview-gitea-actions/)
---------
Co-authored-by: a1012112796 <1012112796@qq.com>
Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: delvh <dev.lh@web.de>
Co-authored-by: ChristopherHX <christopher.homberger@web.de>
Co-authored-by: John Olheiser <john.olheiser@gmail.com>
2023-01-30 20:45:19 -05:00
issue . Poster , err = user_model . GetPossibleUserByID ( ctx , issue . PosterID )
2016-03-13 23:20:22 -04:00
if err != nil {
2016-09-20 05:54:47 -04:00
issue . PosterID = - 1
2021-11-24 04:49:20 -05:00
issue . Poster = user_model . NewGhostUser ( )
if ! user_model . IsErrUserNotExist ( err ) {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getUserByID.(poster) [%d]: %w" , issue . PosterID , err )
2016-03-13 23:20:22 -04:00
}
2016-11-09 00:07:01 -05:00
err = nil
2016-03-13 23:20:22 -04:00
return
}
2016-08-26 16:40:53 -04:00
}
2022-06-20 06:02:49 -04:00
return err
2017-01-30 07:46:45 -05:00
}
2016-03-13 23:20:22 -04:00
2022-11-19 03:12:33 -05:00
// LoadPullRequest loads pull request info
func ( issue * Issue ) LoadPullRequest ( ctx context . Context ) ( err error ) {
2023-02-20 19:15:49 -05:00
if issue . IsPull {
if issue . PullRequest == nil {
issue . PullRequest , err = GetPullRequestByIssueID ( ctx , issue . ID )
if err != nil {
if IsErrPullRequestNotExist ( err ) {
return err
}
return fmt . Errorf ( "getPullRequestByIssueID [%d]: %w" , issue . ID , err )
2017-07-26 03:16:45 -04:00
}
}
2018-12-13 10:55:43 -05:00
issue . PullRequest . Issue = issue
2017-07-26 03:16:45 -04:00
}
return nil
}
2022-05-20 10:08:52 -04:00
func ( issue * Issue ) loadComments ( ctx context . Context ) ( err error ) {
return issue . loadCommentsByType ( ctx , CommentTypeUnknown )
2019-02-19 09:39:39 -05:00
}
// LoadDiscussComments loads discuss comments
2022-11-19 03:12:33 -05:00
func ( issue * Issue ) LoadDiscussComments ( ctx context . Context ) error {
return issue . loadCommentsByType ( ctx , CommentTypeComment )
2019-02-19 09:39:39 -05:00
}
2022-05-20 10:08:52 -04:00
func ( issue * Issue ) loadCommentsByType ( ctx context . Context , tp CommentType ) ( err error ) {
2017-09-16 16:16:21 -04:00
if issue . Comments != nil {
return nil
}
2022-05-20 10:08:52 -04:00
issue . Comments , err = FindComments ( ctx , & FindCommentsOptions {
2017-09-16 16:16:21 -04:00
IssueID : issue . ID ,
2019-02-19 09:39:39 -05:00
Type : tp ,
2017-09-16 16:16:21 -04:00
} )
return err
}
2021-12-09 20:27:50 -05:00
func ( issue * Issue ) loadReactions ( ctx context . Context ) ( err error ) {
2017-12-03 18:14:26 -05:00
if issue . Reactions != nil {
return nil
}
2022-06-13 05:37:59 -04:00
reactions , _ , err := FindReactions ( ctx , FindReactionsOptions {
2017-12-03 18:14:26 -05:00
IssueID : issue . ID ,
} )
if err != nil {
return err
}
2022-04-08 05:11:15 -04:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2020-01-15 06:14:07 -05:00
return err
}
2017-12-03 18:14:26 -05:00
// Load reaction user data
2022-06-20 06:02:49 -04:00
if _ , err := reactions . LoadUsers ( ctx , issue . Repo ) ; 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
}
2022-11-19 03:12:33 -05:00
// LoadMilestone load milestone of this issue.
func ( issue * Issue ) LoadMilestone ( ctx context . Context ) ( err error ) {
2020-05-24 10:38:34 -04:00
if ( issue . Milestone == nil || issue . Milestone . ID != issue . MilestoneID ) && issue . MilestoneID > 0 {
2022-06-13 05:37:59 -04:00
issue . Milestone , err = GetMilestoneByRepoID ( ctx , issue . RepoID , issue . MilestoneID )
if err != nil && ! IsErrMilestoneNotExist ( err ) {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getMilestoneByRepoID [repo_id: %d, milestone_id: %d]: %w" , issue . RepoID , issue . MilestoneID , err )
2020-01-01 17:51:10 -05:00
}
}
return nil
}
2022-06-13 05:37:59 -04:00
// LoadAttributes loads the attribute of this issue.
func ( issue * Issue ) LoadAttributes ( ctx context . Context ) ( err error ) {
2022-04-08 05:11:15 -04:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2017-01-30 07:46:45 -05:00
return
}
2022-11-19 03:12:33 -05:00
if err = issue . LoadPoster ( ctx ) ; err != nil {
2017-01-30 07:46:45 -05:00
return
}
2022-04-28 07:48:48 -04:00
if err = issue . LoadLabels ( ctx ) ; err != nil {
2017-01-30 07:46:45 -05:00
return
2016-08-26 16:40:53 -04:00
}
2015-08-10 09:47:23 -04:00
2022-11-19 03:12:33 -05:00
if err = issue . LoadMilestone ( ctx ) ; err != nil {
2020-01-01 17:51:10 -05:00
return
2015-08-05 08:23:08 -04:00
}
2023-02-20 14:21:56 -05:00
if err = issue . LoadProject ( ctx ) ; err != nil {
2020-08-16 23:07:38 -04:00
return
}
2022-05-20 10:08:52 -04:00
if err = issue . LoadAssignees ( ctx ) ; err != nil {
2017-06-23 09:43:37 -04:00
return
2016-08-14 06:32:24 -04:00
}
2022-11-19 03:12:33 -05:00
if err = issue . LoadPullRequest ( ctx ) ; err != nil && ! IsErrPullRequestNotExist ( err ) {
2016-08-14 06:32:24 -04:00
// It is possible pull request is not yet created.
2017-07-26 03:16:45 -04:00
return err
2016-08-14 06:32:24 -04:00
}
2016-08-26 16:40:53 -04:00
if issue . Attachments == nil {
2022-05-20 10:08:52 -04:00
issue . Attachments , err = repo_model . GetAttachmentsByIssueID ( ctx , issue . ID )
2016-08-26 16:40:53 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getAttachmentsByIssueID [%d]: %w" , issue . ID , err )
2016-08-26 16:40:53 -04:00
}
}
2022-05-20 10:08:52 -04:00
if err = issue . loadComments ( ctx ) ; err != nil {
2017-12-03 18:14:26 -05:00
return err
2016-08-26 16:40:53 -04:00
}
2019-04-18 01:00:03 -04:00
2021-12-09 20:27:50 -05:00
if err = CommentList ( issue . Comments ) . loadAttributes ( ctx ) ; err != nil {
2019-04-18 01:00:03 -04:00
return err
}
2022-12-09 21:46:31 -05:00
if issue . IsTimetrackerEnabled ( ctx ) {
2022-06-13 05:37:59 -04:00
if err = issue . LoadTotalTimes ( ctx ) ; err != nil {
2018-04-29 01:58:47 -04:00
return err
}
}
2016-08-26 16:40:53 -04:00
2021-12-09 20:27:50 -05:00
return issue . loadReactions ( ctx )
2016-08-14 06:32:24 -04: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 }
2021-09-23 11:45:36 -04:00
if has , err := db . GetEngine ( db . DefaultContext ) . Get ( issueUser ) ; err != nil {
2017-02-03 02:22:39 -05:00
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 {
2020-04-21 09:48:53 -04:00
if issue . Repo == nil {
2022-04-08 05:11:15 -04:00
err := issue . LoadRepo ( db . DefaultContext )
2020-04-21 09:48:53 -04:00
if err != nil {
log . Error ( "Issue[%d].APIURL(): %v" , issue . ID , err )
return ""
}
}
2020-01-14 10:37:19 -05:00
return fmt . Sprintf ( "%s/issues/%d" , issue . Repo . APIURL ( ) , 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 13:19:09 -04: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 )
}
2023-02-06 13:09:18 -05:00
// Link returns the issue's relative URL.
2021-11-16 13:18:25 -05:00
func ( issue * Issue ) Link ( ) string {
var path string
if issue . IsPull {
path = "pulls"
} else {
path = "issues"
}
return fmt . Sprintf ( "%s/%s/%d" , issue . Repo . Link ( ) , 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 23:20:22 -04: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 23:20:22 -04:00
}
2016-11-29 03:25:47 -05:00
return api . StateOpen
2016-08-14 06:32:24 -04:00
}
// HashTag returns unique hash tag for issue.
2016-11-22 06:24:39 -05:00
func ( issue * Issue ) HashTag ( ) string {
2020-12-25 04:59:32 -05:00
return fmt . Sprintf ( "issue-%d" , issue . ID )
2016-03-13 23:20:22 -04:00
}
2015-08-13 04:07:11 -04: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 {
2020-01-17 05:23:46 -05:00
return issue . OriginalAuthorID == 0 && issue . PosterID == uid
2015-08-13 04:07:11 -04:00
}
2022-05-20 10:08:52 -04:00
func ( issue * Issue ) getLabels ( ctx context . Context ) ( err error ) {
2016-08-03 14:51:22 -04:00
if len ( issue . Labels ) > 0 {
2014-05-24 02:31:58 -04:00
return nil
}
2022-05-20 10:08:52 -04:00
issue . Labels , err = GetLabelsByIssueID ( ctx , issue . ID )
2015-08-10 02:42:50 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getLabelsByIssueID: %w" , err )
2014-05-24 02:31:58 -04:00
}
return nil
}
2022-03-29 10:57:33 -04:00
func clearIssueLabels ( ctx context . Context , issue * Issue , doer * user_model . User ) ( err error ) {
2022-05-20 10:08:52 -04:00
if err = issue . getLabels ( ctx ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getLabels: %w" , err )
2016-08-03 14:51:22 -04:00
}
for i := range issue . Labels {
2022-03-29 10:57:33 -04:00
if err = deleteIssueLabel ( ctx , issue , issue . Labels [ i ] , doer ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "removeLabel: %w" , err )
2016-08-03 14:51:22 -04:00
}
}
return nil
}
2022-03-29 10:57:33 -04:00
// ClearIssueLabels removes all issue labels as the given user.
2016-11-24 03:41:11 -05:00
// Triggers appropriate WebHooks, if any.
2022-03-29 10:57:33 -04:00
func ClearIssueLabels ( issue * Issue , doer * user_model . User ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2015-08-14 12:42:43 -04:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2015-08-14 12:42:43 -04:00
2022-04-08 05:11:15 -04:00
if err := issue . LoadRepo ( ctx ) ; err != nil {
2016-12-17 06:49:17 -05:00
return err
2022-11-19 03:12:33 -05:00
} else if err = issue . LoadPullRequest ( ctx ) ; err != nil {
2017-07-26 03:16:45 -04:00
return err
2016-12-17 06:49:17 -05:00
}
2022-05-11 06:09:36 -04:00
perm , err := access_model . GetUserRepoPermission ( ctx , issue . Repo , doer )
2018-11-28 06:26:14 -05:00
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 ) {
Add Organization Wide Labels (#10814)
* Add organization wide labels
Implement organization wide labels similar to organization wide
webhooks. This lets you create individual labels for organizations that can be used
for all repos under that organization (so being able to reuse the same
label across multiple repos).
This makes it possible for small organizations with many repos to use
labels effectively.
Fixes #7406
* Add migration
* remove comments
* fix tests
* Update options/locale/locale_en-US.ini
Removed unused translation string
* show org labels in issue search label filter
* Use more clear var name
* rename migration after merge from master
* comment typo
* update migration again after rebase with master
* check for orgID <=0 per guillep2k review
* fmt
* Apply suggestions from code review
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* remove unused code
* Make sure RepoID is 0 when searching orgID per code review
* more changes/code review requests
* More descriptive translation var per code review
* func description/delete comment when issue label deleted instead of hiding it
* remove comment
* only use issues in that repo when calculating number of open issues for org label on repo label page
* Add integration test for IssuesSearch API with labels
* remove unused function
* Update models/issue_label.go
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* Use subquery in GetLabelIDsInReposByNames
* Fix tests to use correct orgID
* fix more tests
* IssuesSearch api now uses new BuildLabelNamesIssueIDsCondition. Add a few more tests as well
* update comment for clarity
* Revert previous code change now that we can use the new BuildLabelNamesIssueIDsCondition
* Don't sort repos by date in IssuesSearch API
After much debugging I've found a strange issue where in some cases MySQL will return a different result than other enigines if a query is sorted by a null collumn. For example with our integration test data where we don't set updated_unix in repository fixtures:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 45
Returns different results for MySQL than other engines. However, the similar query:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 30
Returns the same results.
This causes integration tests to fail on MySQL in certain cases but would never show up in a real installation. Since this API call always returns issues based on the optionally provided repo_priority_id or the issueID itself, there is no change to results by changing the repo sorting method used to get ids earlier in the function.
* linter is back!
* code review
* remove now unused option
* Fix newline at end of files
* more unused code
* update to master
* check for matching ids before query
* Update models/issue_label.go
Co-Authored-By: 6543 <6543@obermui.de>
* Update models/issue_label.go
* update comments
* Update routers/org/setting.go
Co-authored-by: Lauris BH <lauris@nix.lv>
Co-authored-by: guillep2k <18600385+guillep2k@users.noreply.github.com>
Co-authored-by: 6543 <6543@obermui.de>
2020-04-01 00:14:46 -04:00
return ErrRepoLabelNotExist { }
2016-12-17 06:49:17 -05:00
}
2022-03-29 10:57:33 -04:00
if err = clearIssueLabels ( ctx , issue , doer ) ; err != nil {
2015-08-14 12:42:43 -04:00
return err
}
2021-09-19 07:49:59 -04:00
if err = committer . Commit ( ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "Commit: %w" , err )
2016-08-14 06:32:24 -04:00
}
return nil
2015-08-14 12:42:43 -04: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 ]
}
Scoped labels (#22585)
Add a new "exclusive" option per label. This makes it so that when the
label is named `scope/name`, no other label with the same `scope/`
prefix can be set on an issue.
The scope is determined by the last occurence of `/`, so for example
`scope/alpha/name` and `scope/beta/name` are considered to be in
different scopes and can coexist.
Exclusive scopes are not enforced by any database rules, however they
are enforced when editing labels at the models level, automatically
removing any existing labels in the same scope when either attaching a
new label or replacing all labels.
In menus use a circle instead of checkbox to indicate they function as
radio buttons per scope. Issue filtering by label ensures that only a
single scoped label is selected at a time. Clicking with alt key can be
used to remove a scoped label, both when editing individual issues and
batch editing.
Label rendering refactor for consistency and code simplification:
* Labels now consistently have the same shape, emojis and tooltips
everywhere. This includes the label list and label assignment menus.
* In label list, show description below label same as label menus.
* Don't use exactly black/white text colors to look a bit nicer.
* Simplify text color computation. There is no point computing luminance
in linear color space, as this is a perceptual problem and sRGB is
closer to perceptually linear.
* Increase height of label assignment menus to show more labels. Showing
only 3-4 labels at a time leads to a lot of scrolling.
* Render all labels with a new RenderLabel template helper function.
Label creation and editing in multiline modal menu:
* Change label creation to open a modal menu like label editing.
* Change menu layout to place name, description and colors on separate
lines.
* Don't color cancel button red in label editing modal menu.
* Align text to the left in model menu for better readability and
consistent with settings layout elsewhere.
Custom exclusive scoped label rendering:
* Display scoped label prefix and suffix with slightly darker and
lighter background color respectively, and a slanted edge between them
similar to the `/` symbol.
* In menus exclusive labels are grouped with a divider line.
---------
Co-authored-by: Yarden Shoham <hrsi88@gmail.com>
Co-authored-by: Lauris BH <lauris@nix.lv>
2023-02-18 14:17:39 -05:00
// Ensure only one label of a given scope exists, with labels at the end of the
// array getting preference over earlier ones.
func RemoveDuplicateExclusiveLabels ( labels [ ] * Label ) [ ] * Label {
validLabels := make ( [ ] * Label , 0 , len ( labels ) )
for i , label := range labels {
scope := label . ExclusiveScope ( )
if scope != "" {
foundOther := false
for _ , otherLabel := range labels [ i + 1 : ] {
if otherLabel . ExclusiveScope ( ) == scope {
foundOther = true
break
}
}
if foundOther {
continue
}
}
validLabels = append ( validLabels , label )
}
return validLabels
}
2022-03-29 10:57:33 -04:00
// ReplaceIssueLabels removes all current labels and add new labels to the issue.
2016-11-24 03:41:11 -05:00
// Triggers appropriate WebHooks, if any.
2022-03-29 10:57:33 -04:00
func ReplaceIssueLabels ( issue * Issue , labels [ ] * Label , doer * user_model . User ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2015-08-14 12:42:43 -04:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2015-08-14 12:42:43 -04:00
2022-04-08 05:11:15 -04:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2021-03-12 12:45:49 -05:00
return err
}
2022-04-28 07:48:48 -04:00
if err = issue . LoadLabels ( ctx ) ; err != nil {
2017-01-30 07:46:45 -05:00
return err
}
Scoped labels (#22585)
Add a new "exclusive" option per label. This makes it so that when the
label is named `scope/name`, no other label with the same `scope/`
prefix can be set on an issue.
The scope is determined by the last occurence of `/`, so for example
`scope/alpha/name` and `scope/beta/name` are considered to be in
different scopes and can coexist.
Exclusive scopes are not enforced by any database rules, however they
are enforced when editing labels at the models level, automatically
removing any existing labels in the same scope when either attaching a
new label or replacing all labels.
In menus use a circle instead of checkbox to indicate they function as
radio buttons per scope. Issue filtering by label ensures that only a
single scoped label is selected at a time. Clicking with alt key can be
used to remove a scoped label, both when editing individual issues and
batch editing.
Label rendering refactor for consistency and code simplification:
* Labels now consistently have the same shape, emojis and tooltips
everywhere. This includes the label list and label assignment menus.
* In label list, show description below label same as label menus.
* Don't use exactly black/white text colors to look a bit nicer.
* Simplify text color computation. There is no point computing luminance
in linear color space, as this is a perceptual problem and sRGB is
closer to perceptually linear.
* Increase height of label assignment menus to show more labels. Showing
only 3-4 labels at a time leads to a lot of scrolling.
* Render all labels with a new RenderLabel template helper function.
Label creation and editing in multiline modal menu:
* Change label creation to open a modal menu like label editing.
* Change menu layout to place name, description and colors on separate
lines.
* Don't color cancel button red in label editing modal menu.
* Align text to the left in model menu for better readability and
consistent with settings layout elsewhere.
Custom exclusive scoped label rendering:
* Display scoped label prefix and suffix with slightly darker and
lighter background color respectively, and a slanted edge between them
similar to the `/` symbol.
* In menus exclusive labels are grouped with a divider line.
---------
Co-authored-by: Yarden Shoham <hrsi88@gmail.com>
Co-authored-by: Lauris BH <lauris@nix.lv>
2023-02-18 14:17:39 -05:00
labels = RemoveDuplicateExclusiveLabels ( labels )
2017-01-30 07:46:45 -05:00
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 {
2021-03-12 12:45:49 -05:00
// Silently drop invalid labels
if removeLabel . RepoID != issue . RepoID && removeLabel . OrgID != issue . Repo . OwnerID {
toRemove = append ( toRemove , removeLabel )
}
2017-02-27 20:35:55 -05:00
addIndex ++
removeIndex ++
} else if addLabel . ID < removeLabel . ID {
2021-03-12 12:45:49 -05:00
// Only add if the label is valid
if addLabel . RepoID == issue . RepoID || addLabel . OrgID == issue . Repo . OwnerID {
toAdd = append ( toAdd , addLabel )
}
2017-02-27 20:35:55 -05:00
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 {
2022-03-29 10:57:33 -04:00
if err = newIssueLabels ( ctx , issue , toAdd , doer ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "addLabels: %w" , err )
2017-01-30 07:46:45 -05:00
}
}
2017-02-27 20:35:55 -05:00
for _ , l := range toRemove {
2022-03-29 10:57:33 -04:00
if err = deleteIssueLabel ( ctx , issue , l , doer ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "removeLabel: %w" , err )
2017-01-30 07:46:45 -05:00
}
2015-08-14 12:42:43 -04:00
}
2020-10-05 02:49:11 -04:00
issue . Labels = nil
2022-04-28 07:48:48 -04:00
if err = issue . LoadLabels ( ctx ) ; err != nil {
2020-10-05 02:49:11 -04:00
return err
}
2021-09-19 07:49:59 -04:00
return committer . Commit ( )
2015-08-10 02:42:50 -04:00
}
2022-04-08 05:11:15 -04:00
// UpdateIssueCols updates cols of issue
func UpdateIssueCols ( ctx context . Context , issue * Issue , cols ... string ) error {
2022-01-17 13:31:58 -05:00
if _ , err := db . GetEngine ( ctx ) . ID ( issue . ID ) . Cols ( cols ... ) . Update ( issue ) ; err != nil {
2017-01-24 21:43:02 -05:00
return err
}
return nil
2016-08-14 06:32:24 -04:00
}
2022-03-29 10:57:33 -04:00
func changeIssueStatus ( ctx context . Context , issue * Issue , doer * user_model . User , isClosed , isMergePull bool ) ( * Comment , error ) {
2019-03-04 21:52:52 -05:00
// Reload the issue
2022-06-13 05:37:59 -04:00
currentIssue , err := GetIssueByID ( ctx , issue . ID )
2019-03-04 21:52:52 -05:00
if err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2019-03-04 21:52:52 -05:00
}
2016-03-05 12:58:51 -05:00
// Nothing should be performed if current status is same as target status
2019-03-04 21:52:52 -05:00
if currentIssue . IsClosed == isClosed {
2019-12-15 16:57:34 -05:00
if ! issue . IsPull {
return nil , ErrIssueWasClosed {
ID : issue . ID ,
}
}
return nil , ErrPullWasClosed {
ID : issue . ID ,
}
2015-08-13 04:07:11 -04:00
}
2018-07-17 17:23:58 -04:00
2020-05-16 17:05:19 -04:00
issue . IsClosed = isClosed
2022-03-29 10:57:33 -04:00
return doChangeIssueStatus ( ctx , issue , doer , isMergePull )
2020-05-16 17:05:19 -04:00
}
2022-03-29 10:57:33 -04:00
func doChangeIssueStatus ( ctx context . Context , issue * Issue , doer * user_model . User , isMergePull bool ) ( * Comment , error ) {
2018-07-17 17:23:58 -04:00
// Check for open dependencies
2022-12-09 21:46:31 -05:00
if issue . IsClosed && issue . Repo . IsDependenciesEnabled ( ctx ) {
2018-07-17 17:23:58 -04: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
2022-05-03 15:46:28 -04:00
noDeps , err := IssueNoDependenciesLeft ( ctx , issue )
2018-07-17 17:23:58 -04:00
if err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2018-07-17 17:23:58 -04:00
}
if ! noDeps {
2019-12-15 16:57:34 -05:00
return nil , ErrDependenciesLeft { issue . ID }
2018-07-17 17:23:58 -04:00
}
}
2020-05-16 17:05:19 -04:00
if issue . IsClosed {
2019-08-15 10:46:21 -04:00
issue . ClosedUnix = timeutil . TimeStampNow ( )
2018-02-18 21:39:26 -05:00
} else {
issue . ClosedUnix = 0
}
2015-08-13 04:07:11 -04:00
2022-04-08 05:11:15 -04:00
if err := UpdateIssueCols ( ctx , issue , "is_closed" , "closed_unix" ) ; err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2015-08-13 04:07:11 -04:00
}
2016-03-05 12:58:51 -05:00
// Update issue count of labels
2022-05-20 10:08:52 -04:00
if err := issue . getLabels ( ctx ) ; err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2015-08-13 04:07:11 -04:00
}
2016-11-22 06:24:39 -05:00
for idx := range issue . Labels {
2022-05-20 10:08:52 -04:00
if err := updateLabelCols ( ctx , issue . Labels [ idx ] , "num_issues" , "num_closed_issue" ) ; err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2015-08-13 04:07:11 -04:00
}
}
2016-03-05 12:58:51 -05:00
// Update issue count of milestone
2021-06-21 14:34:58 -04:00
if issue . MilestoneID > 0 {
2022-06-13 05:37:59 -04:00
if err := UpdateMilestoneCounters ( ctx , issue . MilestoneID ) ; err != nil {
2021-06-21 14:34:58 -04:00
return nil , err
}
2015-08-13 04:07:11 -04:00
}
2022-10-25 08:47:46 -04:00
// update repository's issue closed number
if err := repo_model . UpdateRepoIssueNumbers ( ctx , issue . RepoID , issue . IsPull , true ) ; err != nil {
2020-02-20 02:46:46 -05:00
return nil , err
}
2016-03-05 12:58:51 -05:00
// New action comment
2019-11-15 13:18:09 -05:00
cmtType := CommentTypeClose
if ! issue . IsClosed {
cmtType = CommentTypeReopen
2020-04-13 21:06:23 -04:00
} else if isMergePull {
cmtType = CommentTypeMergePull
2019-11-15 13:18:09 -05:00
}
2019-11-30 21:44:39 -05:00
2022-12-09 21:46:31 -05:00
return CreateComment ( ctx , & CreateCommentOptions {
2019-11-15 13:18:09 -05:00
Type : cmtType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
2019-12-15 16:57:34 -05:00
} )
2015-08-13 04:07:11 -04:00
}
2022-03-29 10:57:33 -04:00
// ChangeIssueStatus changes issue status to open or closed.
2022-05-03 15:46:28 -04:00
func ChangeIssueStatus ( ctx context . Context , issue * Issue , doer * user_model . User , isClosed bool ) ( * Comment , error ) {
2022-04-08 05:11:15 -04:00
if err := issue . LoadRepo ( ctx ) ; err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2018-12-13 10:55:43 -05:00
}
2022-11-19 03:12:33 -05:00
if err := issue . LoadPoster ( ctx ) ; err != nil {
2019-12-15 16:57:34 -05:00
return nil , err
2018-12-13 10:55:43 -05:00
}
2022-05-03 15:46:28 -04:00
return changeIssueStatus ( ctx , issue , doer , isClosed , false )
2016-08-14 06:32:24 -04:00
}
2022-03-29 10:57:33 -04:00
// ChangeIssueTitle changes the title of this issue, as the given user.
func ChangeIssueTitle ( issue * Issue , doer * user_model . User , oldTitle string ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2017-02-05 09:36:00 -05:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2017-02-05 09:36:00 -05:00
2022-04-08 05:11:15 -04:00
if err = UpdateIssueCols ( ctx , issue , "name" ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "updateIssueCols: %w" , err )
2017-02-05 09:36:00 -05:00
}
2022-04-08 05:11:15 -04:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "loadRepo: %w" , err )
2018-12-13 10:55:43 -05:00
}
2021-03-14 14:52:12 -04:00
opts := & CreateCommentOptions {
2019-11-15 13:18:09 -05:00
Type : CommentTypeChangeTitle ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
OldTitle : oldTitle ,
NewTitle : issue . Title ,
2019-11-30 21:44:39 -05:00
}
2022-12-09 21:46:31 -05:00
if _ , err = CreateComment ( ctx , opts ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "createComment: %w" , err )
2017-02-05 09:36:00 -05:00
}
2022-06-13 05:37:59 -04:00
if err = issue . AddCrossReferences ( ctx , doer , true ) ; err != nil {
2019-09-20 01:45:38 -04:00
return err
}
2021-09-19 07:49:59 -04:00
return committer . Commit ( )
2015-08-13 04:07:11 -04:00
}
2022-03-29 10:57:33 -04:00
// ChangeIssueRef changes the branch of this issue, as the given user.
func ChangeIssueRef ( issue * Issue , doer * user_model . User , oldRef string ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2020-09-08 12:29:51 -04:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2020-09-08 12:29:51 -04:00
2022-04-08 05:11:15 -04:00
if err = UpdateIssueCols ( ctx , issue , "ref" ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "updateIssueCols: %w" , err )
2020-09-08 12:29:51 -04:00
}
2022-04-08 05:11:15 -04:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "loadRepo: %w" , err )
2021-11-19 04:54:31 -05:00
}
2021-12-02 02:28:08 -05:00
oldRefFriendly := strings . TrimPrefix ( oldRef , git . BranchPrefix )
newRefFriendly := strings . TrimPrefix ( issue . Ref , git . BranchPrefix )
2021-11-19 04:54:31 -05:00
opts := & CreateCommentOptions {
Type : CommentTypeChangeIssueRef ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
OldRef : oldRefFriendly ,
NewRef : newRefFriendly ,
}
2022-12-09 21:46:31 -05:00
if _ , err = CreateComment ( ctx , opts ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "createComment: %w" , err )
2021-11-19 04:54:31 -05:00
}
2021-09-19 07:49:59 -04:00
return committer . Commit ( )
2020-09-08 12:29:51 -04:00
}
2017-02-10 23:00:29 -05:00
// AddDeletePRBranchComment adds delete branch comment for pull request issue
2022-05-03 15:46:28 -04:00
func AddDeletePRBranchComment ( ctx context . Context , doer * user_model . User , repo * repo_model . Repository , issueID int64 , branchName string ) error {
2022-06-13 05:37:59 -04:00
issue , err := GetIssueByID ( ctx , issueID )
2021-09-19 07:49:59 -04:00
if err != nil {
2017-02-10 23:00:29 -05:00
return err
}
2021-03-14 14:52:12 -04:00
opts := & CreateCommentOptions {
2021-02-07 22:09:14 -05:00
Type : CommentTypeDeleteBranch ,
Doer : doer ,
Repo : repo ,
Issue : issue ,
OldRef : branchName ,
2019-11-30 21:44:39 -05:00
}
2022-12-09 21:46:31 -05:00
_ , err = CreateComment ( ctx , opts )
2022-05-03 15:46:28 -04:00
return err
2017-02-10 23:00:29 -05:00
}
2022-03-29 10:57:33 -04:00
// UpdateIssueAttachments update attachments by UUIDs for the issue
func UpdateIssueAttachments ( issueID int64 , uuids [ ] string ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2019-10-15 08:19:32 -04:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2021-11-19 08:39:57 -05:00
attachments , err := repo_model . GetAttachmentsByUUIDs ( ctx , uuids )
2019-10-15 08:19:32 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %w" , uuids , err )
2019-10-15 08:19:32 -04:00
}
for i := 0 ; i < len ( attachments ) ; i ++ {
2022-03-29 10:57:33 -04:00
attachments [ i ] . IssueID = issueID
2022-05-20 10:08:52 -04:00
if err := repo_model . UpdateAttachment ( ctx , attachments [ i ] ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "update attachment [id: %d]: %w" , attachments [ i ] . ID , err )
2019-10-15 08:19:32 -04:00
}
}
2021-09-19 07:49:59 -04:00
return committer . Commit ( )
2019-10-15 08:19:32 -04:00
}
2022-03-29 10:57:33 -04:00
// ChangeIssueContent changes issue content, as the given user.
func ChangeIssueContent ( issue * Issue , doer * user_model . User , content string ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2019-09-20 01:45:38 -04:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2019-09-20 01:45:38 -04:00
2022-06-13 05:37:59 -04:00
hasContentHistory , err := HasIssueContentHistory ( ctx , issue . ID , 0 )
2021-11-22 07:20:16 -05:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "HasIssueContentHistory: %w" , err )
2021-11-22 07:20:16 -05:00
}
if ! hasContentHistory {
2022-06-13 05:37:59 -04:00
if err = SaveIssueContentHistory ( ctx , issue . PosterID , issue . ID , 0 ,
2021-11-22 07:20:16 -05:00
issue . CreatedUnix , issue . Content , true ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "SaveIssueContentHistory: %w" , err )
2021-11-22 07:20:16 -05:00
}
}
issue . Content = content
2022-04-08 05:11:15 -04:00
if err = UpdateIssueCols ( ctx , issue , "content" ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "UpdateIssueCols: %w" , err )
2016-08-14 06:32:24 -04:00
}
2019-11-18 18:43:03 -05:00
2022-06-13 05:37:59 -04:00
if err = SaveIssueContentHistory ( ctx , doer . ID , issue . ID , 0 ,
2021-10-10 18:40:03 -04:00
timeutil . TimeStampNow ( ) , issue . Content , false ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "SaveIssueContentHistory: %w" , err )
2021-10-10 18:40:03 -04:00
}
2022-06-13 05:37:59 -04:00
if err = issue . AddCrossReferences ( ctx , doer , true ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "addCrossReferences: %w" , err )
2019-09-20 01:45:38 -04:00
}
2021-09-19 07:49:59 -04:00
return committer . Commit ( )
2016-08-14 06:32:24 -04:00
}
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 ) )
}
2019-02-13 03:14:17 -05:00
// GetLastEventTimestamp returns the last user visible event timestamp, either the creation of this issue or the close.
2019-08-15 10:46:21 -04:00
func ( issue * Issue ) GetLastEventTimestamp ( ) timeutil . TimeStamp {
2019-02-13 03:14:17 -05:00
if issue . IsClosed {
return issue . ClosedUnix
}
return issue . CreatedUnix
}
// GetLastEventLabel returns the localization label for the current issue.
func ( issue * Issue ) GetLastEventLabel ( ) string {
if issue . IsClosed {
if issue . IsPull && issue . PullRequest . HasMerged {
return "repo.pulls.merged_by"
}
return "repo.issues.closed_by"
}
return "repo.issues.opened_by"
}
2020-01-09 06:56:32 -05:00
// GetLastComment return last comment for the current issue.
func ( issue * Issue ) GetLastComment ( ) ( * Comment , error ) {
var c Comment
2021-09-23 11:45:36 -04:00
exist , err := db . GetEngine ( db . DefaultContext ) . Where ( "type = ?" , CommentTypeComment ) .
2021-10-06 16:36:24 -04:00
And ( "issue_id = ?" , issue . ID ) . Desc ( "created_unix" ) . Get ( & c )
2020-01-09 06:56:32 -05:00
if err != nil {
return nil , err
}
if ! exist {
return nil , nil
}
return & c , nil
}
2019-03-27 18:22:39 -04:00
// GetLastEventLabelFake returns the localization label for the current issue without providing a link in the username.
func ( issue * Issue ) GetLastEventLabelFake ( ) string {
if issue . IsClosed {
if issue . IsPull && issue . PullRequest . HasMerged {
return "repo.pulls.merged_by_fake"
}
return "repo.issues.closed_by_fake"
}
return "repo.issues.opened_by_fake"
}
2016-11-24 03:41:11 -05:00
// NewIssueOptions represents the options of a new issue.
2016-08-15 21:40:32 -04:00
type NewIssueOptions struct {
2021-12-09 20:27:50 -05:00
Repo * repo_model . Repository
2016-08-15 21:40:32 -04:00
Issue * Issue
2017-02-28 20:08:45 -05:00
LabelIDs [ ] int64
2016-08-15 21:40:32 -04:00
Attachments [ ] string // In UUID format.
IsPull bool
}
2016-03-13 23:20:22 -04:00
2022-06-13 05:37:59 -04:00
// NewIssueWithIndex creates issue with given index
func NewIssueWithIndex ( ctx context . Context , doer * user_model . User , opts NewIssueOptions ) ( err error ) {
2021-11-19 08:39:57 -05:00
e := db . GetEngine ( ctx )
2016-08-15 21:40:32 -04:00
opts . Issue . Title = strings . TrimSpace ( opts . Issue . Title )
2019-05-17 22:37:49 -04:00
2016-08-16 13:19:09 -04:00
if opts . Issue . MilestoneID > 0 {
2022-06-13 05:37:59 -04:00
milestone , err := GetMilestoneByRepoID ( ctx , opts . Issue . RepoID , opts . Issue . MilestoneID )
if err != nil && ! IsErrMilestoneNotExist ( err ) {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getMilestoneByID: %w" , err )
2016-08-16 13:19:09 -04:00
}
// Assume milestone is invalid and drop silently.
opts . Issue . MilestoneID = 0
if milestone != nil {
opts . Issue . MilestoneID = milestone . ID
opts . Issue . Milestone = milestone
}
}
2021-06-13 22:22:55 -04:00
if opts . Issue . Index <= 0 {
return fmt . Errorf ( "no issue index provided" )
}
if opts . Issue . ID > 0 {
return fmt . Errorf ( "issue exist" )
2019-08-26 22:17:23 -04:00
}
2021-06-13 22:22:55 -04:00
if _ , err := e . Insert ( opts . Issue ) ; err != nil {
2014-05-07 12:09:30 -04:00
return err
2015-09-02 16:18:09 -04:00
}
2017-01-31 21:36:08 -05:00
if opts . Issue . MilestoneID > 0 {
2022-06-13 05:37:59 -04:00
if err := UpdateMilestoneCounters ( ctx , opts . Issue . MilestoneID ) ; err != nil {
2017-01-31 21:36:08 -05:00
return err
}
2019-10-25 03:19:04 -04:00
2021-03-14 14:52:12 -04:00
opts := & CreateCommentOptions {
2019-11-30 21:44:39 -05:00
Type : CommentTypeMilestone ,
Doer : doer ,
Repo : opts . Repo ,
Issue : opts . Issue ,
OldMilestoneID : 0 ,
MilestoneID : opts . Issue . MilestoneID ,
}
2022-12-09 21:46:31 -05:00
if _ , err = CreateComment ( ctx , opts ) ; err != nil {
2019-10-25 03:19:04 -04:00
return err
}
2017-01-31 21:36:08 -05:00
}
2022-12-06 02:53:09 -05:00
if err := repo_model . UpdateRepoIssueNumbers ( ctx , opts . Issue . RepoID , opts . IsPull , false ) ; err != nil {
2014-05-07 12:09:30 -04:00
return err
2014-03-27 12:48:29 -04:00
}
2014-07-22 07:50:34 -04: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 {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "find all labels [label_ids: %v]: %w" , opts . LabelIDs , err )
2016-03-05 20:45:23 -05:00
}
2015-08-14 12:42:43 -04:00
2022-11-19 03:12:33 -05:00
if err = opts . Issue . LoadPoster ( ctx ) ; err != nil {
2017-01-30 07:46:45 -05:00
return err
}
2016-03-05 20:45:23 -05:00
for _ , label := range labels {
2016-08-15 21:40:32 -04:00
// Silently drop invalid labels.
Add Organization Wide Labels (#10814)
* Add organization wide labels
Implement organization wide labels similar to organization wide
webhooks. This lets you create individual labels for organizations that can be used
for all repos under that organization (so being able to reuse the same
label across multiple repos).
This makes it possible for small organizations with many repos to use
labels effectively.
Fixes #7406
* Add migration
* remove comments
* fix tests
* Update options/locale/locale_en-US.ini
Removed unused translation string
* show org labels in issue search label filter
* Use more clear var name
* rename migration after merge from master
* comment typo
* update migration again after rebase with master
* check for orgID <=0 per guillep2k review
* fmt
* Apply suggestions from code review
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* remove unused code
* Make sure RepoID is 0 when searching orgID per code review
* more changes/code review requests
* More descriptive translation var per code review
* func description/delete comment when issue label deleted instead of hiding it
* remove comment
* only use issues in that repo when calculating number of open issues for org label on repo label page
* Add integration test for IssuesSearch API with labels
* remove unused function
* Update models/issue_label.go
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* Use subquery in GetLabelIDsInReposByNames
* Fix tests to use correct orgID
* fix more tests
* IssuesSearch api now uses new BuildLabelNamesIssueIDsCondition. Add a few more tests as well
* update comment for clarity
* Revert previous code change now that we can use the new BuildLabelNamesIssueIDsCondition
* Don't sort repos by date in IssuesSearch API
After much debugging I've found a strange issue where in some cases MySQL will return a different result than other enigines if a query is sorted by a null collumn. For example with our integration test data where we don't set updated_unix in repository fixtures:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 45
Returns different results for MySQL than other engines. However, the similar query:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 30
Returns the same results.
This causes integration tests to fail on MySQL in certain cases but would never show up in a real installation. Since this API call always returns issues based on the optionally provided repo_priority_id or the issueID itself, there is no change to results by changing the repo sorting method used to get ids earlier in the function.
* linter is back!
* code review
* remove now unused option
* Fix newline at end of files
* more unused code
* update to master
* check for matching ids before query
* Update models/issue_label.go
Co-Authored-By: 6543 <6543@obermui.de>
* Update models/issue_label.go
* update comments
* Update routers/org/setting.go
Co-authored-by: Lauris BH <lauris@nix.lv>
Co-authored-by: guillep2k <18600385+guillep2k@users.noreply.github.com>
Co-authored-by: 6543 <6543@obermui.de>
2020-04-01 00:14:46 -04:00
if label . RepoID != opts . Repo . ID && label . OrgID != opts . Repo . OwnerID {
2016-03-13 23:20:22 -04:00
continue
}
2022-03-29 10:57:33 -04:00
if err = newIssueLabel ( ctx , opts . Issue , label , opts . Issue . Poster ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "addLabel [id: %d]: %w" , label . ID , err )
2016-03-05 20:45:23 -05:00
}
2015-08-10 04:52:08 -04:00
}
}
2022-06-13 05:37:59 -04:00
if err = NewIssueUsers ( ctx , opts . Repo , opts . Issue ) ; err != nil {
2015-08-10 09:47:23 -04:00
return err
}
2016-08-15 21:40:32 -04:00
if len ( opts . Attachments ) > 0 {
2021-11-19 08:39:57 -05:00
attachments , err := repo_model . GetAttachmentsByUUIDs ( ctx , opts . Attachments )
2015-09-01 19:07:02 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %w" , opts . Attachments , err )
2015-09-01 19:07:02 -04:00
}
2016-08-15 21:40:32 -04:00
for i := 0 ; i < len ( attachments ) ; i ++ {
attachments [ i ] . IssueID = opts . Issue . ID
2017-10-05 00:43:04 -04:00
if _ , err = e . ID ( attachments [ i ] . ID ) . Update ( attachments [ i ] ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "update attachment [id: %d]: %w" , attachments [ i ] . ID , err )
2016-08-15 21:40:32 -04:00
}
2015-08-11 11:24:40 -04:00
}
}
2022-06-13 05:37:59 -04:00
if err = opts . Issue . LoadAttributes ( ctx ) ; err != nil {
2019-09-20 01:45:38 -04:00
return err
}
2021-10-10 18:40:03 -04:00
2022-06-13 05:37:59 -04:00
return opts . Issue . AddCrossReferences ( ctx , doer , false )
2021-08-13 09:06:18 -04:00
}
2015-09-01 19:07:02 -04:00
// NewIssue creates new issue with labels for repository.
2021-12-09 20:27:50 -05:00
func NewIssue ( repo * repo_model . Repository , issue * Issue , labelIDs [ ] int64 , uuids [ ] string ) ( err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-09-19 07:49:59 -04:00
if err != nil {
2015-09-01 19:07:02 -04:00
return err
}
2021-09-19 07:49:59 -04:00
defer committer . Close ( )
2015-09-01 19:07:02 -04:00
2022-10-16 06:44:16 -04:00
idx , err := db . GetNextResourceIndex ( ctx , "issue_index" , repo . ID )
if err != nil {
return fmt . Errorf ( "generate issue index failed: %w" , err )
}
issue . Index = idx
2022-06-13 05:37:59 -04:00
if err = NewIssueWithIndex ( ctx , issue . Poster , NewIssueOptions {
2016-08-15 21:40:32 -04:00
Repo : repo ,
Issue : issue ,
2017-02-28 20:08:45 -05:00
LabelIDs : labelIDs ,
2016-08-15 21:40:32 -04:00
Attachments : uuids ,
} ) ; err != nil {
2022-06-13 05:37:59 -04:00
if repo_model . IsErrUserDoesNotHaveAccessToRepo ( err ) || IsErrNewIssueInsert ( err ) {
2018-05-09 12:29:04 -04:00
return err
}
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "newIssue: %w" , err )
2015-09-01 19:07:02 -04:00
}
2021-09-19 07:49:59 -04:00
if err = committer . Commit ( ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "Commit: %w" , err )
2016-03-13 23:20:22 -04:00
}
return nil
2014-03-20 16:04:56 -04: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 ) {
2021-07-12 16:22:27 -04:00
if index < 1 {
return nil , ErrIssueNotExist { }
}
2015-08-12 05:04:23 -04:00
issue := & Issue {
RepoID : repoID ,
Index : index ,
}
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( db . DefaultContext ) . Get ( issue )
2014-03-22 16:00:46 -04:00
if err != nil {
return nil , err
} else if ! has {
2015-08-12 05:04:23 -04:00
return nil , ErrIssueNotExist { 0 , repoID , index }
2014-03-22 16:00:46 -04:00
}
2016-08-26 16:40:53 -04: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 16:40:53 -04:00
if err != nil {
return nil , err
}
2022-06-13 05:37:59 -04:00
return issue , issue . LoadAttributes ( db . DefaultContext )
2014-03-22 16:00:46 -04:00
}
2022-06-13 05:37:59 -04:00
// GetIssueByID returns an issue by given ID.
func GetIssueByID ( ctx context . Context , id int64 ) ( * Issue , error ) {
2015-08-12 05:04:23 -04:00
issue := new ( Issue )
2022-05-20 10:08:52 -04:00
has , err := db . GetEngine ( ctx ) . ID ( id ) . Get ( issue )
2014-05-07 16:51:14 -04:00
if err != nil {
return nil , err
} else if ! has {
2015-08-12 05:04:23 -04:00
return nil , ErrIssueNotExist { id , 0 , 0 }
2014-05-07 16:51:14 -04: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 ) {
2022-06-13 05:37:59 -04:00
issue , err := GetIssueByID ( db . DefaultContext , id )
2018-12-13 10:55:43 -05:00
if err != nil {
return nil , err
}
2022-06-13 05:37:59 -04:00
return issue , issue . LoadAttributes ( db . DefaultContext )
2016-08-14 06:32:24 -04:00
}
2022-05-20 10:08:52 -04:00
// GetIssuesByIDs return issues with the given IDs.
2023-01-20 06:42:33 -05:00
func GetIssuesByIDs ( ctx context . Context , issueIDs [ ] int64 ) ( IssueList , error ) {
2017-03-14 21:10:35 -04:00
issues := make ( [ ] * Issue , 0 , 10 )
2022-05-20 10:08:52 -04:00
return issues , db . GetEngine ( ctx ) . In ( "id" , issueIDs ) . Find ( & issues )
2017-03-14 21:10:35 -04:00
}
2022-05-20 10:08:52 -04:00
// GetIssueIDsByRepoID returns all issue ids by repo id
func GetIssueIDsByRepoID ( ctx context . Context , repoID int64 ) ( [ ] int64 , error ) {
2021-03-14 14:52:12 -04:00
ids := make ( [ ] int64 , 0 , 10 )
2022-05-20 10:08:52 -04:00
err := db . GetEngine ( ctx ) . Table ( "issue" ) . Cols ( "id" ) . Where ( "repo_id = ?" , repoID ) . Find ( & ids )
2019-02-19 09:39:39 -05:00
return ids , err
}
2016-11-24 03:41:11 -05:00
// IssuesOptions represents options of an issue.
2022-06-13 05:37:59 -04:00
type IssuesOptions struct { //nolint
2021-09-24 07:32:56 -04:00
db . ListOptions
2022-04-25 10:06:24 -04:00
RepoID int64 // overwrites RepoCond if not 0
RepoCond builder . Cond
2020-03-30 01:30:39 -04:00
AssigneeID int64
PosterID int64
MentionedID int64
2021-01-17 11:34:19 -05:00
ReviewRequestedID int64
2022-09-29 15:09:14 -04:00
SubscriberID int64
2020-04-30 00:15:39 -04:00
MilestoneIDs [ ] int64
2020-08-16 23:07:38 -04:00
ProjectID int64
ProjectBoardID int64
2020-03-30 01:30:39 -04:00
IsClosed util . OptionalBool
IsPull util . OptionalBool
LabelIDs [ ] int64
IncludedLabelNames [ ] string
ExcludedLabelNames [ ] string
2021-06-17 02:40:59 -04:00
IncludeMilestones [ ] string
2020-03-30 01:30:39 -04:00
SortType string
IssueIDs [ ] int64
2020-11-23 15:49:36 -05:00
UpdatedAfterUnix int64
UpdatedBeforeUnix int64
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
// prioritize issues from this repo
PriorityRepoID int64
2021-01-12 23:19:17 -05:00
IsArchived util . OptionalBool
2022-03-29 02:29:02 -04:00
Org * organization . Organization // issues permission scope
Team * organization . Team // issues permission scope
User * user_model . User // issues permission scope
2015-09-02 16:18:09 -04:00
}
2017-01-01 13:15:09 -05:00
// sortIssuesSession sort an issues-related session based on the provided
// sortType string
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
func sortIssuesSession ( sess * xorm . Session , sortType string , priorityRepoID int64 ) {
2017-01-01 13:15:09 -05:00
switch sortType {
case "oldest" :
2021-12-28 22:12:19 -05:00
sess . Asc ( "issue.created_unix" ) . Asc ( "issue.id" )
2017-01-01 13:15:09 -05:00
case "recentupdate" :
2021-12-28 22:12:19 -05:00
sess . Desc ( "issue.updated_unix" ) . Desc ( "issue.created_unix" ) . Desc ( "issue.id" )
2017-01-01 13:15:09 -05:00
case "leastupdate" :
2021-12-28 22:12:19 -05:00
sess . Asc ( "issue.updated_unix" ) . Asc ( "issue.created_unix" ) . Asc ( "issue.id" )
2017-01-01 13:15:09 -05:00
case "mostcomment" :
2021-12-28 22:12:19 -05:00
sess . Desc ( "issue.num_comments" ) . Desc ( "issue.created_unix" ) . Desc ( "issue.id" )
2017-01-01 13:15:09 -05:00
case "leastcomment" :
2021-12-28 22:12:19 -05:00
sess . Asc ( "issue.num_comments" ) . Desc ( "issue.created_unix" ) . Desc ( "issue.id" )
2017-01-01 13:15:09 -05:00
case "priority" :
2021-12-28 22:12:19 -05:00
sess . Desc ( "issue.priority" ) . Desc ( "issue.created_unix" ) . Desc ( "issue.id" )
2019-03-05 09:39:41 -05:00
case "nearduedate" :
2019-11-09 08:09:01 -05:00
// 253370764800 is 01/01/9999 @ 12:00am (UTC)
2021-06-14 21:15:56 -04:00
sess . Join ( "LEFT" , "milestone" , "issue.milestone_id = milestone.id" ) .
OrderBy ( "CASE " +
"WHEN issue.deadline_unix = 0 AND (milestone.deadline_unix = 0 OR milestone.deadline_unix IS NULL) THEN 253370764800 " +
"WHEN milestone.deadline_unix = 0 OR milestone.deadline_unix IS NULL THEN issue.deadline_unix " +
"WHEN milestone.deadline_unix < issue.deadline_unix OR issue.deadline_unix = 0 THEN milestone.deadline_unix " +
2021-12-28 22:12:19 -05:00
"ELSE issue.deadline_unix END ASC" ) .
Desc ( "issue.created_unix" ) .
Desc ( "issue.id" )
2019-03-05 09:39:41 -05:00
case "farduedate" :
2021-06-14 21:15:56 -04:00
sess . Join ( "LEFT" , "milestone" , "issue.milestone_id = milestone.id" ) .
OrderBy ( "CASE " +
"WHEN milestone.deadline_unix IS NULL THEN issue.deadline_unix " +
"WHEN milestone.deadline_unix < issue.deadline_unix OR issue.deadline_unix = 0 THEN milestone.deadline_unix " +
2021-12-28 22:12:19 -05:00
"ELSE issue.deadline_unix END DESC" ) .
Desc ( "issue.created_unix" ) .
Desc ( "issue.id" )
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
case "priorityrepo" :
2022-06-04 15:18:50 -04:00
sess . OrderBy ( "CASE " +
"WHEN issue.repo_id = ? THEN 1 " +
"ELSE 2 END ASC" , priorityRepoID ) .
2021-12-28 22:12:19 -05:00
Desc ( "issue.created_unix" ) .
Desc ( "issue.id" )
2021-12-08 01:57:18 -05:00
case "project-column-sorting" :
2021-12-28 22:12:19 -05:00
sess . Asc ( "project_issue.sorting" ) . Desc ( "issue.created_unix" ) . Desc ( "issue.id" )
2017-01-01 13:15:09 -05:00
default :
2021-12-28 22:12:19 -05:00
sess . Desc ( "issue.created_unix" ) . Desc ( "issue.id" )
2017-01-01 13:15:09 -05:00
}
}
2022-04-07 22:39:03 -04:00
func ( opts * IssuesOptions ) setupSessionWithLimit ( sess * xorm . Session ) {
2017-08-03 01:09:16 -04:00
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 01:09:16 -04:00
start = ( opts . Page - 1 ) * opts . PageSize
2017-01-24 21:43:02 -05:00
}
2017-08-03 01:09:16 -04:00
sess . Limit ( opts . PageSize , start )
2016-03-13 23:20:22 -04:00
}
2022-04-07 22:39:03 -04:00
opts . setupSessionNoLimit ( sess )
}
2016-03-13 23:20:22 -04:00
2022-04-07 22:39:03 -04:00
func ( opts * IssuesOptions ) setupSessionNoLimit ( sess * xorm . Session ) {
2017-01-24 21:43:02 -05:00
if len ( opts . IssueIDs ) > 0 {
sess . In ( "issue.id" , opts . IssueIDs )
}
2014-03-22 16:00:46 -04:00
2022-04-25 10:06:24 -04:00
if opts . RepoID != 0 {
opts . RepoCond = builder . Eq { "issue.repo_id" : opts . RepoID }
}
if opts . RepoCond != nil {
sess . And ( opts . RepoCond )
2014-03-22 16:00:46 -04:00
}
2017-01-24 21:43:02 -05:00
2022-04-25 10:06:24 -04:00
if ! opts . IsClosed . IsNone ( ) {
sess . And ( "issue.is_closed=?" , opts . IsClosed . IsTrue ( ) )
2017-01-24 21:43:02 -05:00
}
2014-03-22 16:00:46 -04:00
2015-09-02 16:18:09 -04:00
if opts . AssigneeID > 0 {
2021-01-17 11:34:19 -05:00
applyAssigneeCondition ( sess , opts . AssigneeID )
2016-12-24 05:33:21 -05:00
}
if opts . PosterID > 0 {
2021-01-17 11:34:19 -05:00
applyPosterCondition ( sess , opts . PosterID )
2014-03-22 13:50:50 -04:00
}
2016-12-24 05:33:21 -05:00
if opts . MentionedID > 0 {
2021-01-17 11:34:19 -05:00
applyMentionedCondition ( sess , opts . MentionedID )
}
if opts . ReviewRequestedID > 0 {
applyReviewRequestedCondition ( sess , opts . ReviewRequestedID )
2016-12-24 05:33:21 -05:00
}
2022-09-29 15:09:14 -04:00
if opts . SubscriberID > 0 {
applySubscribedCondition ( sess , opts . SubscriberID )
}
2020-04-30 00:15:39 -04:00
if len ( opts . MilestoneIDs ) > 0 {
sess . In ( "issue.milestone_id" , opts . MilestoneIDs )
2014-03-22 13:50:50 -04:00
}
2020-11-23 15:49:36 -05:00
if opts . UpdatedAfterUnix != 0 {
sess . And ( builder . Gte { "issue.updated_unix" : opts . UpdatedAfterUnix } )
}
if opts . UpdatedBeforeUnix != 0 {
sess . And ( builder . Lte { "issue.updated_unix" : opts . UpdatedBeforeUnix } )
}
2020-08-16 23:07:38 -04:00
if opts . ProjectID > 0 {
sess . Join ( "INNER" , "project_issue" , "issue.id = project_issue.issue_id" ) .
And ( "project_issue.project_id=?" , opts . ProjectID )
2023-02-04 09:35:08 -05:00
} else if opts . ProjectID == db . NoneID { // show those that are in no project
sess . And ( builder . NotIn ( "issue.id" , builder . Select ( "issue_id" ) . From ( "project_issue" ) ) )
2020-08-16 23:07:38 -04:00
}
if opts . ProjectBoardID != 0 {
if opts . ProjectBoardID > 0 {
sess . In ( "issue.id" , builder . Select ( "issue_id" ) . From ( "project_issue" ) . Where ( builder . Eq { "project_board_id" : opts . ProjectBoardID } ) )
} else {
sess . In ( "issue.id" , builder . Select ( "issue_id" ) . From ( "project_issue" ) . Where ( builder . Eq { "project_board_id" : 0 } ) )
}
}
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 16:18:09 -04:00
2021-01-12 23:19:17 -05:00
if opts . IsArchived != util . OptionalBoolNone {
2021-01-26 17:47:42 -05:00
sess . And ( builder . Eq { "repository.is_archived" : opts . IsArchived . IsTrue ( ) } )
2021-01-12 23:19:17 -05:00
}
2019-01-22 23:10:38 -05:00
if opts . LabelIDs != nil {
for i , labelID := range opts . LabelIDs {
2019-10-23 12:29:14 -04:00
if labelID > 0 {
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 ) )
} else {
sess . Where ( "issue.id not in (select issue_id from issue_label where label_id = ?)" , - labelID )
}
2016-04-26 00:22:03 -04:00
}
2015-08-10 09:47:23 -04:00
}
2020-03-30 01:30:39 -04:00
if len ( opts . IncludedLabelNames ) > 0 {
sess . In ( "issue.id" , BuildLabelNamesIssueIDsCondition ( opts . IncludedLabelNames ) )
}
if len ( opts . ExcludedLabelNames ) > 0 {
sess . And ( builder . NotIn ( "issue.id" , BuildLabelNamesIssueIDsCondition ( opts . ExcludedLabelNames ) ) )
}
2021-06-17 02:40:59 -04:00
if len ( opts . IncludeMilestones ) > 0 {
sess . In ( "issue.milestone_id" ,
builder . Select ( "id" ) .
From ( "milestone" ) .
Where ( builder . In ( "name" , opts . IncludeMilestones ) ) )
}
2021-12-29 08:02:12 -05:00
if opts . User != nil {
2022-05-16 05:49:17 -04:00
sess . And ( issuePullAccessibleRepoCond ( "issue.repo_id" , opts . User . ID , opts . Org , opts . Team , opts . IsPull . IsTrue ( ) ) )
2021-12-29 08:02:12 -05:00
}
}
2022-06-06 04:01:49 -04:00
// teamUnitsRepoCond returns query condition for those repo id in the special org team with special units access
func teamUnitsRepoCond ( id string , userID , orgID , teamID int64 , units ... unit . Type ) builder . Cond {
return builder . In ( id ,
builder . Select ( "repo_id" ) . From ( "team_repo" ) . Where (
builder . Eq {
"team_id" : teamID ,
} . And (
builder . Or (
// Check if the user is member of the team.
builder . In (
"team_id" , builder . Select ( "team_id" ) . From ( "team_user" ) . Where (
builder . Eq {
"uid" : userID ,
} ,
) ,
) ,
// Check if the user is in the owner team of the organisation.
builder . Exists ( builder . Select ( "team_id" ) . From ( "team_user" ) .
Where ( builder . Eq {
"org_id" : orgID ,
"team_id" : builder . Select ( "id" ) . From ( "team" ) . Where (
builder . Eq {
"org_id" : orgID ,
"lower_name" : strings . ToLower ( organization . OwnerTeamName ) ,
} ) ,
"uid" : userID ,
} ) ,
) ,
) ) . And (
builder . In (
"team_id" , builder . Select ( "team_id" ) . From ( "team_unit" ) . Where (
builder . Eq {
"`team_unit`.org_id" : orgID ,
} . And (
builder . In ( "`team_unit`.type" , units ) ,
) ,
) ,
) ,
) ,
) )
}
2021-12-29 08:02:12 -05:00
// issuePullAccessibleRepoCond userID must not be zero, this condition require join repository table
2022-03-29 02:29:02 -04:00
func issuePullAccessibleRepoCond ( repoIDstr string , userID int64 , org * organization . Organization , team * organization . Team , isPull bool ) builder . Cond {
2022-01-04 22:37:00 -05:00
cond := builder . NewCond ( )
unitType := unit . TypeIssues
2021-12-29 08:02:12 -05:00
if isPull {
unitType = unit . TypePullRequests
}
if org != nil {
if team != nil {
cond = cond . And ( teamUnitsRepoCond ( repoIDstr , userID , org . ID , team . ID , unitType ) ) // special team member repos
} else {
cond = cond . And (
builder . Or (
2022-06-06 04:01:49 -04:00
repo_model . UserOrgUnitRepoCond ( repoIDstr , userID , org . ID , unitType ) , // team member repos
repo_model . UserOrgPublicUnitRepoCond ( userID , org . ID ) , // user org public non-member repos, TODO: check repo has issues
2021-12-29 08:02:12 -05:00
) ,
)
}
} else {
cond = cond . And (
builder . Or (
2022-06-06 04:01:49 -04:00
repo_model . UserOwnedRepoCond ( userID ) , // owned repos
2022-06-15 19:24:10 -04:00
repo_model . UserAccessRepoCond ( repoIDstr , userID ) , // user can access repo in a unit independent way
2022-06-06 04:01:49 -04:00
repo_model . UserAssignedRepoCond ( repoIDstr , userID ) , // user has been assigned accessible public repos
repo_model . UserMentionedRepoCond ( repoIDstr , userID ) , // user has been mentioned accessible public repos
repo_model . UserCreateIssueRepoCond ( repoIDstr , userID , isPull ) , // user has created issue/pr accessible public repos
2021-12-29 08:02:12 -05:00
) ,
)
}
return cond
2017-08-03 01:09:16 -04:00
}
2021-01-17 11:34:19 -05:00
func applyAssigneeCondition ( sess * xorm . Session , assigneeID int64 ) * xorm . Session {
return sess . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , assigneeID )
}
func applyPosterCondition ( sess * xorm . Session , posterID int64 ) * xorm . Session {
return sess . And ( "issue.poster_id=?" , posterID )
}
func applyMentionedCondition ( sess * xorm . Session , mentionedID int64 ) * xorm . Session {
return sess . Join ( "INNER" , "issue_user" , "issue.id = issue_user.issue_id" ) .
And ( "issue_user.is_mentioned = ?" , true ) .
And ( "issue_user.uid = ?" , mentionedID )
}
func applyReviewRequestedCondition ( sess * xorm . Session , reviewRequestedID int64 ) * xorm . Session {
return sess . Join ( "INNER" , [ ] string { "review" , "r" } , "issue.id = r.issue_id" ) .
2021-01-18 00:13:15 -05:00
And ( "issue.poster_id <> ?" , reviewRequestedID ) .
2021-01-17 11:34:19 -05:00
And ( "r.type = ?" , ReviewTypeRequest ) .
And ( "r.reviewer_id = ? and r.id in (select max(id) from review where issue_id = r.issue_id and reviewer_id = r.reviewer_id and type in (?, ?, ?))" +
" or r.reviewer_team_id in (select team_id from team_user where uid = ?)" ,
reviewRequestedID , ReviewTypeApprove , ReviewTypeReject , ReviewTypeRequest , reviewRequestedID )
}
2022-09-29 15:09:14 -04:00
func applySubscribedCondition ( sess * xorm . Session , subscriberID int64 ) * xorm . Session {
return sess . And (
builder .
NotIn ( "issue.id" ,
builder . Select ( "issue_id" ) .
From ( "issue_watch" ) .
Where ( builder . Eq { "is_watching" : false , "user_id" : subscriberID } ) ,
) ,
) . And (
builder . Or (
builder . In ( "issue.id" , builder .
Select ( "issue_id" ) .
From ( "issue_watch" ) .
Where ( builder . Eq { "is_watching" : true , "user_id" : subscriberID } ) ,
) ,
builder . In ( "issue.id" , builder .
Select ( "issue_id" ) .
From ( "comment" ) .
Where ( builder . Eq { "poster_id" : subscriberID } ) ,
) ,
builder . Eq { "issue.poster_id" : subscriberID } ,
builder . In ( "issue.repo_id" , builder .
Select ( "id" ) .
From ( "watch" ) .
2022-10-18 04:01:02 -04:00
Where ( builder . And ( builder . Eq { "user_id" : subscriberID } ,
builder . In ( "mode" , repo_model . WatchModeNormal , repo_model . WatchModeAuto ) ) ) ,
2022-09-29 15:09:14 -04:00
) ,
) ,
)
}
2017-08-03 01:09:16 -04:00
// CountIssuesByRepo map from repoID to number of issues matching the options
2022-11-19 03:12:33 -05:00
func CountIssuesByRepo ( ctx context . Context , opts * IssuesOptions ) ( map [ int64 ] int64 , error ) {
sess := db . GetEngine ( ctx ) .
Join ( "INNER" , "repository" , "`issue`.repo_id = `repository`.id" )
2021-01-26 17:47:42 -05:00
2022-04-07 22:39:03 -04:00
opts . setupSessionNoLimit ( sess )
2017-08-03 01:09:16 -04:00
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 {
2022-04-07 22:39:03 -04:00
return nil , fmt . Errorf ( "unable to CountIssuesByRepo: %w" , err )
2017-08-03 01:09:16 -04:00
}
countMap := make ( map [ int64 ] int64 , len ( countsSlice ) )
for _ , c := range countsSlice {
countMap [ c . RepoID ] = c . Count
}
return countMap , nil
}
2020-02-29 01:52:05 -05:00
// GetRepoIDsForIssuesOptions find all repo ids for the given options
2021-11-24 04:49:20 -05:00
func GetRepoIDsForIssuesOptions ( opts * IssuesOptions , user * user_model . User ) ( [ ] int64 , error ) {
2020-02-29 01:52:05 -05:00
repoIDs := make ( [ ] int64 , 0 , 5 )
2021-11-21 10:41:00 -05:00
e := db . GetEngine ( db . DefaultContext )
2020-02-29 01:52:05 -05:00
2021-11-21 10:41:00 -05:00
sess := e . Join ( "INNER" , "repository" , "`issue`.repo_id = `repository`.id" )
2021-01-26 17:47:42 -05:00
2022-04-07 22:39:03 -04:00
opts . setupSessionNoLimit ( sess )
2020-02-29 01:52:05 -05:00
2022-06-15 19:24:10 -04:00
accessCond := repo_model . AccessibleRepositoryCondition ( user , unit . TypeInvalid )
2020-02-29 01:52:05 -05:00
if err := sess . Where ( accessCond ) .
Distinct ( "issue.repo_id" ) .
Table ( "issue" ) .
Find ( & repoIDs ) ; err != nil {
2022-04-07 22:39:03 -04:00
return nil , fmt . Errorf ( "unable to GetRepoIDsForIssuesOptions: %w" , err )
2020-02-29 01:52:05 -05:00
}
return repoIDs , nil
}
2017-08-03 01:09:16 -04:00
// Issues returns a list of issues by given conditions.
2022-11-19 03:12:33 -05:00
func Issues ( ctx context . Context , opts * IssuesOptions ) ( [ ] * Issue , error ) {
sess := db . GetEngine ( ctx ) .
Join ( "INNER" , "repository" , "`issue`.repo_id = `repository`.id" )
2022-04-07 22:39:03 -04:00
opts . setupSessionWithLimit ( sess )
2022-05-16 05:49:17 -04:00
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
sortIssuesSession ( sess , opts . SortType , opts . PriorityRepoID )
2015-08-10 09:47:23 -04:00
2020-09-24 19:30:40 -04:00
issues := make ( [ ] * Issue , 0 , opts . ListOptions . PageSize )
2016-08-26 16:40:53 -04:00
if err := sess . Find ( & issues ) ; err != nil {
2022-04-07 22:39:03 -04:00
return nil , fmt . Errorf ( "unable to query Issues: %w" , err )
2016-08-26 16:40:53 -04:00
}
2017-02-22 09:03:59 -05:00
if err := IssueList ( issues ) . LoadAttributes ( ) ; err != nil {
2022-04-07 22:39:03 -04:00
return nil , fmt . Errorf ( "unable to LoadAttributes for Issues: %w" , err )
2016-08-26 16:40:53 -04:00
}
return issues , nil
2020-09-24 19:30:40 -04:00
}
// CountIssues number return of issues by given conditions.
2022-11-19 03:12:33 -05:00
func CountIssues ( ctx context . Context , opts * IssuesOptions ) ( int64 , error ) {
sess := db . GetEngine ( ctx ) .
Select ( "COUNT(issue.id) AS count" ) .
Table ( "issue" ) .
Join ( "INNER" , "repository" , "`issue`.repo_id = `repository`.id" )
2022-04-07 22:39:03 -04:00
opts . setupSessionNoLimit ( sess )
2022-05-16 05:49:17 -04:00
2022-04-25 03:04:42 -04:00
return sess . Count ( )
2014-03-22 13:50:50 -04:00
}
2019-11-18 03:08:20 -05:00
// GetParticipantsIDsByIssueID returns the IDs of all users who participated in comments of an issue,
// but skips joining with `user` for performance reasons.
// User permissions must be verified elsewhere if required.
2022-11-19 03:12:33 -05:00
func GetParticipantsIDsByIssueID ( ctx context . Context , issueID int64 ) ( [ ] int64 , error ) {
2019-11-18 03:08:20 -05:00
userIDs := make ( [ ] int64 , 0 , 5 )
2022-11-19 03:12:33 -05:00
return userIDs , db . GetEngine ( ctx ) .
Table ( "comment" ) .
2019-11-18 03:08:20 -05:00
Cols ( "poster_id" ) .
Where ( "issue_id = ?" , issueID ) .
And ( "type in (?,?,?)" , CommentTypeComment , CommentTypeCode , CommentTypeReview ) .
Distinct ( "poster_id" ) .
Find ( & userIDs )
}
2020-02-28 03:16:41 -05:00
// IsUserParticipantsOfIssue return true if user is participants of an issue
2021-11-24 04:49:20 -05:00
func IsUserParticipantsOfIssue ( user * user_model . User , issue * Issue ) bool {
2022-06-13 05:37:59 -04:00
userIDs , err := issue . GetParticipantIDsByIssue ( db . DefaultContext )
2020-02-28 03:16:41 -05:00
if err != nil {
log . Error ( err . Error ( ) )
return false
2017-03-15 21:34:24 -04:00
}
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 00:31:16 -05:00
return util . SliceContains ( userIDs , user . ID )
2017-03-15 21:34:24 -04:00
}
2019-10-10 12:45:11 -04:00
// UpdateIssueMentions updates issue-user relations for mentioned users.
2021-11-24 04:49:20 -05:00
func UpdateIssueMentions ( ctx context . Context , issueID int64 , mentions [ ] * user_model . User ) error {
2016-07-15 12:36:39 -04:00
if len ( mentions ) == 0 {
return nil
2015-12-21 07:24:11 -05:00
}
2019-10-10 12:45:11 -04:00
ids := make ( [ ] int64 , len ( mentions ) )
for i , u := range mentions {
ids [ i ] = u . ID
2015-12-21 07:24:11 -05:00
}
2019-09-24 01:02:49 -04:00
if err := UpdateIssueUsersByMentions ( ctx , issueID , ids ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "UpdateIssueUsersByMentions: %w" , err )
2015-12-21 07:24:11 -05:00
}
return nil
}
2014-05-07 12:09:30 -04: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 12:09:30 -04:00
AssignCount int64
CreateCount int64
MentionCount int64
2021-01-17 11:34:19 -05:00
ReviewRequestedCount int64
2014-05-07 12:09:30 -04:00
}
// Filter modes.
const (
2016-11-07 11:24:59 -05:00
FilterModeAll = iota
FilterModeAssign
FilterModeCreate
FilterModeMention
2021-01-17 11:34:19 -05:00
FilterModeReviewRequested
2022-03-23 18:57:09 -04:00
FilterModeYourRepositories
2014-05-07 12:09:30 -04:00
)
2016-11-24 03:41:11 -05:00
// IssueStatsOptions contains parameters accepted by GetIssueStats.
2015-09-02 16:18:09 -04:00
type IssueStatsOptions struct {
2021-01-17 11:34:19 -05:00
RepoID int64
Labels string
MilestoneID int64
2023-01-28 22:45:29 -05:00
ProjectID int64
2021-01-17 11:34:19 -05:00
AssigneeID int64
MentionedID int64
PosterID int64
ReviewRequestedID int64
IsPull util . OptionalBool
IssueIDs [ ] int64
2015-09-02 16:18:09 -04:00
}
2021-09-19 07:49:59 -04:00
const (
2022-06-13 05:37:59 -04:00
// MaxQueryParameters represents the max query parameters
2021-09-19 07:49:59 -04:00
// When queries are broken down in parts because of the number
// of parameters, attempt to break by this amount
2022-06-13 05:37:59 -04:00
MaxQueryParameters = 300
2021-09-19 07:49:59 -04:00
)
2014-05-07 16:51:14 -04:00
// GetIssueStats returns issue statistic information by given conditions.
2017-01-24 21:43:02 -05:00
func GetIssueStats ( opts * IssueStatsOptions ) ( * IssueStats , error ) {
2022-06-13 05:37:59 -04:00
if len ( opts . IssueIDs ) <= MaxQueryParameters {
2020-02-15 05:51:25 -05:00
return getIssueStatsChunk ( opts , opts . IssueIDs )
}
// If too long a list of IDs is provided, we get the statistics in
// smaller chunks and get accumulates. Note: this could potentially
// get us invalid results. The alternative is to insert the list of
// ids in a temporary table and join from them.
accum := & IssueStats { }
for i := 0 ; i < len ( opts . IssueIDs ) ; {
2022-06-13 05:37:59 -04:00
chunk := i + MaxQueryParameters
2020-02-15 05:51:25 -05:00
if chunk > len ( opts . IssueIDs ) {
chunk = len ( opts . IssueIDs )
}
stats , err := getIssueStatsChunk ( opts , opts . IssueIDs [ i : chunk ] )
if err != nil {
return nil , err
}
accum . OpenCount += stats . OpenCount
accum . ClosedCount += stats . ClosedCount
accum . YourRepositoriesCount += stats . YourRepositoriesCount
accum . AssignCount += stats . AssignCount
accum . CreateCount += stats . CreateCount
accum . OpenCount += stats . MentionCount
2021-01-17 11:34:19 -05:00
accum . ReviewRequestedCount += stats . ReviewRequestedCount
2020-02-15 05:51:25 -05:00
i = chunk
}
return accum , nil
}
func getIssueStatsChunk ( opts * IssueStatsOptions , issueIDs [ ] int64 ) ( * IssueStats , error ) {
2014-05-07 12:09:30 -04:00
stats := & IssueStats { }
2015-07-24 14:52:25 -04:00
2021-11-08 16:14:46 -05:00
countSession := func ( opts * IssueStatsOptions , issueIDs [ ] int64 ) * xorm . Session {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) .
2018-11-28 20:46:30 -05:00
Where ( "issue.repo_id = ?" , opts . RepoID )
2015-08-10 09:47:23 -04:00
2021-11-08 16:14:46 -05:00
if len ( issueIDs ) > 0 {
sess . In ( "issue.id" , issueIDs )
2017-01-24 21:43:02 -05:00
}
2016-05-06 15:40:41 -04: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 {
2019-11-05 01:48:51 -05:00
if labelID > 0 {
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 ) )
} else {
sess . Where ( "issue.id NOT IN (SELECT issue_id FROM issue_label WHERE label_id = ?)" , - labelID )
}
2019-01-22 23:10:38 -05:00
}
2016-04-26 00:22:03 -04:00
}
2016-04-26 00:07:49 -04:00
}
if opts . MilestoneID > 0 {
sess . And ( "issue.milestone_id = ?" , opts . MilestoneID )
}
2023-01-28 22:45:29 -05:00
if opts . ProjectID > 0 {
sess . Join ( "INNER" , "project_issue" , "issue.id = project_issue.issue_id" ) .
And ( "project_issue.project_id=?" , opts . ProjectID )
}
2016-04-26 00:07:49 -04:00
if opts . AssigneeID > 0 {
2021-01-17 11:34:19 -05:00
applyAssigneeCondition ( sess , opts . AssigneeID )
2016-04-26 00:07:49 -04:00
}
2016-12-24 05:33:21 -05:00
if opts . PosterID > 0 {
2021-01-17 11:34:19 -05:00
applyPosterCondition ( sess , opts . PosterID )
2016-12-24 05:33:21 -05:00
}
2015-07-24 14:52:25 -04:00
2016-12-24 05:33:21 -05:00
if opts . MentionedID > 0 {
2021-01-17 11:34:19 -05:00
applyMentionedCondition ( sess , opts . MentionedID )
}
if opts . ReviewRequestedID > 0 {
applyReviewRequestedCondition ( sess , opts . ReviewRequestedID )
2016-12-24 05:33:21 -05:00
}
2016-04-26 00:07:49 -04: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 14:52:25 -04:00
}
2016-12-24 05:33:21 -05:00
2017-01-24 21:43:02 -05:00
var err error
2021-11-08 16:14:46 -05:00
stats . OpenCount , err = countSession ( opts , issueIDs ) .
2017-06-14 23:09:03 -04:00
And ( "issue.is_closed = ?" , false ) .
Count ( new ( Issue ) )
if err != nil {
return stats , err
2017-01-24 21:43:02 -05:00
}
2021-11-08 16:14:46 -05:00
stats . ClosedCount , err = countSession ( opts , issueIDs ) .
2017-06-14 23:09:03 -04:00
And ( "issue.is_closed = ?" , true ) .
Count ( new ( Issue ) )
2017-02-14 09:15:18 -05:00
return stats , err
2014-05-07 12:09:30 -04:00
}
2017-12-25 18:25:16 -05:00
// UserIssueStatsOptions contains parameters accepted by GetUserIssueStats.
type UserIssueStatsOptions struct {
2021-12-29 08:02:12 -05:00
UserID int64
RepoIDs [ ] int64
FilterMode int
IsPull bool
IsClosed bool
IssueIDs [ ] int64
IsArchived util . OptionalBool
LabelIDs [ ] int64
2022-03-23 18:57:09 -04:00
RepoCond builder . Cond
2022-03-29 02:29:02 -04:00
Org * organization . Organization
Team * organization . Team
2017-12-25 18:25:16 -05:00
}
2014-05-07 16:51:14 -04: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 12:09:30 -04:00
stats := & IssueStats { }
2015-08-25 10:58:34 -04:00
2017-12-25 18:25:16 -05:00
cond := builder . NewCond ( )
cond = cond . And ( builder . Eq { "issue.is_pull" : opts . IsPull } )
2019-12-01 22:50:36 -05:00
if len ( opts . RepoIDs ) > 0 {
cond = cond . And ( builder . In ( "issue.repo_id" , opts . RepoIDs ) )
2015-09-02 16:18:09 -04:00
}
2020-02-29 01:52:05 -05:00
if len ( opts . IssueIDs ) > 0 {
cond = cond . And ( builder . In ( "issue.id" , opts . IssueIDs ) )
}
2022-03-23 18:57:09 -04:00
if opts . RepoCond != nil {
cond = cond . And ( opts . RepoCond )
}
2015-09-02 16:18:09 -04:00
2021-12-29 08:02:12 -05:00
if opts . UserID > 0 {
cond = cond . And ( issuePullAccessibleRepoCond ( "issue.repo_id" , opts . UserID , opts . Org , opts . Team , opts . IsPull ) )
}
2021-01-01 12:49:42 -05:00
sess := func ( cond builder . Cond ) * xorm . Session {
2021-09-23 11:45:36 -04:00
s := db . GetEngine ( db . DefaultContext ) . Where ( cond )
2021-01-01 12:49:42 -05:00
if len ( opts . LabelIDs ) > 0 {
s . Join ( "INNER" , "issue_label" , "issue_label.issue_id = issue.id" ) .
In ( "issue_label.label_id" , opts . LabelIDs )
}
2021-12-29 08:02:12 -05:00
if opts . UserID > 0 || opts . IsArchived != util . OptionalBoolNone {
s . Join ( "INNER" , "repository" , "issue.repo_id = repository.id" )
if opts . IsArchived != util . OptionalBoolNone {
s . And ( builder . Eq { "repository.is_archived" : opts . IsArchived . IsTrue ( ) } )
}
2021-01-12 23:19:17 -05:00
}
2021-01-01 12:49:42 -05:00
return s
}
2017-12-25 18:25:16 -05:00
switch opts . FilterMode {
2022-03-23 18:57:09 -04:00
case FilterModeAll , FilterModeYourRepositories :
2021-12-29 08:02:12 -05:00
stats . OpenCount , err = sess ( cond ) .
2021-01-17 11:34:19 -05:00
And ( "issue.is_closed = ?" , false ) .
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
}
2021-12-29 08:02:12 -05:00
stats . ClosedCount , err = sess ( cond ) .
2021-01-17 11:34:19 -05:00
And ( "issue.is_closed = ?" , true ) .
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 :
2021-01-17 11:34:19 -05:00
stats . OpenCount , err = applyAssigneeCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , false ) .
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
}
2021-01-17 11:34:19 -05:00
stats . ClosedCount , err = applyAssigneeCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , true ) .
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 :
2021-01-17 11:34:19 -05:00
stats . OpenCount , err = applyPosterCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , false ) .
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
}
2021-01-17 11:34:19 -05:00
stats . ClosedCount , err = applyPosterCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , true ) .
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
}
2019-09-18 03:24:44 -04:00
case FilterModeMention :
2021-01-17 11:34:19 -05:00
stats . OpenCount , err = applyMentionedCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , false ) .
2019-09-18 03:24:44 -04:00
Count ( new ( Issue ) )
if err != nil {
return nil , err
}
2021-01-17 11:34:19 -05:00
stats . ClosedCount , err = applyMentionedCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , true ) .
Count ( new ( Issue ) )
if err != nil {
return nil , err
}
case FilterModeReviewRequested :
stats . OpenCount , err = applyReviewRequestedCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , false ) .
Count ( new ( Issue ) )
if err != nil {
return nil , err
}
stats . ClosedCount , err = applyReviewRequestedCondition ( sess ( cond ) , opts . UserID ) .
And ( "issue.is_closed = ?" , true ) .
2019-09-18 03:24:44 -04:00
Count ( new ( Issue ) )
if err != nil {
return nil , err
}
2017-12-25 18:25:16 -05:00
}
cond = cond . And ( builder . Eq { "issue.is_closed" : opts . IsClosed } )
2021-01-17 11:34:19 -05:00
stats . AssignCount , err = applyAssigneeCondition ( sess ( cond ) , opts . UserID ) . Count ( new ( Issue ) )
2017-12-25 18:25:16 -05:00
if err != nil {
return nil , err
}
2021-01-17 11:34:19 -05:00
stats . CreateCount , err = applyPosterCondition ( sess ( cond ) , opts . UserID ) . Count ( new ( Issue ) )
2017-12-25 18:25:16 -05:00
if err != nil {
return nil , err
}
2021-01-17 11:34:19 -05:00
stats . MentionCount , err = applyMentionedCondition ( sess ( cond ) , opts . UserID ) . Count ( new ( Issue ) )
2019-09-18 03:24:44 -04:00
if err != nil {
return nil , err
}
2021-12-29 08:02:12 -05:00
stats . YourRepositoriesCount , err = sess ( cond ) . Count ( new ( Issue ) )
2021-01-17 11:34:19 -05:00
if err != nil {
return nil , err
}
stats . ReviewRequestedCount , err = applyReviewRequestedCondition ( sess ( cond ) , opts . UserID ) . Count ( new ( Issue ) )
2017-12-25 18:25:16 -05:00
if err != nil {
return nil , err
2015-08-25 10:58:34 -04:00
}
2017-12-25 18:25:16 -05:00
return stats , nil
2014-05-07 12:09:30 -04:00
}
2015-08-25 10:58:34 -04:00
// GetRepoIssueStats returns number of open and closed repository issues by given filter mode.
2021-03-14 14:52:12 -04:00
func GetRepoIssueStats ( repoID , uid int64 , filterMode int , isPull bool ) ( numOpen , numClosed int64 ) {
2016-04-26 00:07:49 -04:00
countSession := func ( isClosed , isPull bool , repoID int64 ) * xorm . Session {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) .
2017-02-09 04:59:57 -05:00
Where ( "is_closed = ?" , isClosed ) .
2016-04-26 00:22:03 -04:00
And ( "is_pull = ?" , isPull ) .
And ( "repo_id = ?" , repoID )
2015-09-02 16:18:09 -04:00
2016-04-26 00:07:49 -04:00
return sess
2015-09-02 16:18:09 -04:00
}
2016-04-26 00:07:49 -04:00
openCountSession := countSession ( false , isPull , repoID )
closedCountSession := countSession ( true , isPull , repoID )
2015-08-25 10:58:34 -04:00
switch filterMode {
2016-11-07 11:24:59 -05:00
case FilterModeAssign :
2021-01-17 11:34:19 -05:00
applyAssigneeCondition ( openCountSession , uid )
applyAssigneeCondition ( closedCountSession , uid )
2016-11-07 11:24:59 -05:00
case FilterModeCreate :
2021-01-17 11:34:19 -05:00
applyPosterCondition ( openCountSession , uid )
applyPosterCondition ( closedCountSession , uid )
2015-08-25 10:58:34 -04:00
}
2017-02-14 09:15:18 -05:00
openResult , _ := openCountSession . Count ( new ( Issue ) )
closedResult , _ := closedCountSession . Count ( new ( Issue ) )
2016-04-26 00:07:49 -04:00
return openResult , closedResult
2015-08-25 10:58:34 -04:00
}
2019-02-21 00:01:28 -05:00
// SearchIssueIDsByKeyword search issues on database
2022-01-27 03:30:51 -05:00
func SearchIssueIDsByKeyword ( ctx context . Context , kw string , repoIDs [ ] int64 , limit , start int ) ( int64 , [ ] int64 , error ) {
2021-03-14 14:52:12 -04:00
repoCond := builder . In ( "repo_id" , repoIDs )
subQuery := builder . Select ( "id" ) . From ( "issue" ) . Where ( repoCond )
cond := builder . And (
2019-02-21 00:01:28 -05:00
repoCond ,
builder . Or (
2022-07-28 12:58:04 -04:00
db . BuildCaseInsensitiveLike ( "name" , kw ) ,
db . BuildCaseInsensitiveLike ( "content" , kw ) ,
2019-02-21 00:01:28 -05:00
builder . In ( "id" , builder . Select ( "issue_id" ) .
From ( "comment" ) .
Where ( builder . And (
builder . Eq { "type" : CommentTypeComment } ,
builder . In ( "issue_id" , subQuery ) ,
2022-07-28 12:58:04 -04:00
db . BuildCaseInsensitiveLike ( "content" , kw ) ,
2019-02-21 00:01:28 -05:00
) ) ,
) ,
) ,
)
2021-03-14 14:52:12 -04:00
ids := make ( [ ] int64 , 0 , limit )
res := make ( [ ] struct {
2021-03-06 10:11:12 -05:00
ID int64
UpdatedUnix int64
} , 0 , limit )
2022-01-27 03:30:51 -05:00
err := db . GetEngine ( ctx ) . Distinct ( "id" , "updated_unix" ) . Table ( "issue" ) . Where ( cond ) .
2021-03-06 10:11:12 -05:00
OrderBy ( "`updated_unix` DESC" ) . Limit ( limit , start ) .
Find ( & res )
2019-02-21 00:01:28 -05:00
if err != nil {
return 0 , nil , err
}
2021-03-06 10:11:12 -05:00
for _ , r := range res {
ids = append ( ids , r . ID )
}
2019-02-21 00:01:28 -05:00
2022-01-27 03:30:51 -05:00
total , err := db . GetEngine ( ctx ) . Distinct ( "id" ) . Table ( "issue" ) . Where ( cond ) . Count ( )
2019-02-21 00:01:28 -05:00
if err != nil {
return 0 , nil , err
}
return total , ids , nil
}
2020-01-01 17:51:10 -05:00
// UpdateIssueByAPI updates all allowed fields of given issue.
2020-05-16 17:05:19 -04:00
// If the issue status is changed a statusChangeComment is returned
// similarly if the title is changed the titleChanged bool is set to true
2021-11-24 04:49:20 -05:00
func UpdateIssueByAPI ( issue * Issue , doer * user_model . User ) ( statusChangeComment * Comment , titleChanged bool , err error ) {
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-11-19 08:39:57 -05:00
if err != nil {
2020-05-16 17:05:19 -04:00
return nil , false , err
}
2021-11-19 08:39:57 -05:00
defer committer . Close ( )
2020-05-16 17:05:19 -04:00
2022-04-08 05:11:15 -04:00
if err := issue . LoadRepo ( ctx ) ; err != nil {
2022-10-24 15:29:17 -04:00
return nil , false , fmt . Errorf ( "loadRepo: %w" , err )
2020-05-16 17:05:19 -04:00
}
// Reload the issue
2022-06-13 05:37:59 -04:00
currentIssue , err := GetIssueByID ( ctx , issue . ID )
2020-05-16 17:05:19 -04:00
if err != nil {
return nil , false , err
2019-09-20 01:45:38 -04:00
}
2020-01-01 17:51:10 -05:00
2022-05-20 10:08:52 -04:00
if _ , err := db . GetEngine ( ctx ) . ID ( issue . ID ) . Cols (
2020-05-16 17:05:19 -04:00
"name" , "content" , "milestone_id" , "priority" ,
"deadline_unix" , "updated_unix" , "is_locked" ) .
2020-01-01 17:51:10 -05:00
Update ( issue ) ; err != nil {
2020-05-16 17:05:19 -04:00
return nil , false , err
2019-09-20 01:45:38 -04:00
}
2020-01-02 02:54:22 -05:00
2020-05-16 17:05:19 -04:00
titleChanged = currentIssue . Title != issue . Title
if titleChanged {
2021-03-14 14:52:12 -04:00
opts := & CreateCommentOptions {
2020-05-16 17:05:19 -04:00
Type : CommentTypeChangeTitle ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
OldTitle : currentIssue . Title ,
NewTitle : issue . Title ,
}
2022-12-09 21:46:31 -05:00
_ , err := CreateComment ( ctx , opts )
2020-05-16 17:05:19 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return nil , false , fmt . Errorf ( "createComment: %w" , err )
2020-05-16 17:05:19 -04:00
}
2020-01-02 02:54:22 -05:00
}
2020-05-16 17:05:19 -04:00
if currentIssue . IsClosed != issue . IsClosed {
2022-03-29 10:57:33 -04:00
statusChangeComment , err = doChangeIssueStatus ( ctx , issue , doer , false )
2020-05-16 17:05:19 -04:00
if err != nil {
return nil , false , err
}
2019-09-20 01:45:38 -04:00
}
2020-05-16 17:05:19 -04:00
2022-06-13 05:37:59 -04:00
if err := issue . AddCrossReferences ( ctx , doer , true ) ; err != nil {
2020-05-16 17:05:19 -04:00
return nil , false , err
}
2021-11-19 08:39:57 -05:00
return statusChangeComment , titleChanged , committer . Commit ( )
2015-10-24 03:36:47 -04:00
}
2018-05-01 15:05:28 -04:00
// UpdateIssueDeadline updates an issue deadline and adds comments. Setting a deadline to 0 means deleting it.
2021-11-24 04:49:20 -05:00
func UpdateIssueDeadline ( issue * Issue , deadlineUnix timeutil . TimeStamp , doer * user_model . User ) ( err error ) {
2018-05-01 15:05:28 -04:00
// if the deadline hasn't changed do nothing
if issue . DeadlineUnix == deadlineUnix {
return nil
}
2022-11-12 15:18:50 -05:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-11-19 08:39:57 -05:00
if err != nil {
2018-05-01 15:05:28 -04:00
return err
}
2021-11-19 08:39:57 -05:00
defer committer . Close ( )
2018-05-01 15:05:28 -04:00
// Update the deadline
2022-04-08 05:11:15 -04:00
if err = UpdateIssueCols ( ctx , & Issue { ID : issue . ID , DeadlineUnix : deadlineUnix } , "deadline_unix" ) ; err != nil {
2018-05-01 15:05:28 -04:00
return err
}
// Make the comment
2021-11-19 08:39:57 -05:00
if _ , err = createDeadlineComment ( ctx , doer , issue , deadlineUnix ) ; err != nil {
2022-10-24 15:29:17 -04:00
return fmt . Errorf ( "createRemovedDueDateComment: %w" , err )
2018-05-01 15:05:28 -04:00
}
2021-11-19 08:39:57 -05:00
return committer . Commit ( )
2018-05-01 15:05:28 -04:00
}
2018-07-17 17:23:58 -04:00
2022-06-13 05:37:59 -04:00
// DeleteInIssue delete records in beans with external key issue_id = ?
func DeleteInIssue ( ctx context . Context , issueID int64 , beans ... interface { } ) error {
2022-05-20 10:08:52 -04:00
e := db . GetEngine ( ctx )
2022-02-28 19:20:15 -05:00
for _ , bean := range beans {
if _ , err := e . In ( "issue_id" , issueID ) . Delete ( bean ) ; err != nil {
return err
}
}
return nil
}
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
// DependencyInfo represents high level information about an issue which is a dependency of another issue.
type DependencyInfo struct {
2021-12-09 20:27:50 -05:00
Issue ` xorm:"extends" `
repo_model . Repository ` xorm:"extends" `
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
}
2022-06-13 05:37:59 -04:00
// GetParticipantIDsByIssue returns all userIDs who are participated in comments of an issue and issue author
func ( issue * Issue ) GetParticipantIDsByIssue ( ctx context . Context ) ( [ ] int64 , error ) {
2020-02-28 03:16:41 -05:00
if issue == nil {
return nil , nil
}
userIDs := make ( [ ] int64 , 0 , 5 )
2022-05-20 10:08:52 -04:00
if err := db . GetEngine ( ctx ) . Table ( "comment" ) . Cols ( "poster_id" ) .
2020-02-28 03:16:41 -05:00
Where ( "`comment`.issue_id = ?" , issue . ID ) .
And ( "`comment`.type in (?,?,?)" , CommentTypeComment , CommentTypeCode , CommentTypeReview ) .
And ( "`user`.is_active = ?" , true ) .
And ( "`user`.prohibit_login = ?" , false ) .
Join ( "INNER" , "`user`" , "`user`.id = `comment`.poster_id" ) .
Distinct ( "poster_id" ) .
Find ( & userIDs ) ; err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "get poster IDs: %w" , err )
2020-02-28 03:16:41 -05:00
}
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 00:31:16 -05:00
if ! util . SliceContains ( userIDs , issue . PosterID ) {
2020-02-28 03:16:41 -05:00
return append ( userIDs , issue . PosterID ) , nil
}
return userIDs , nil
}
2022-05-20 10:08:52 -04:00
// BlockedByDependencies finds all Dependencies an issue is blocked by
func ( issue * Issue ) BlockedByDependencies ( ctx context . Context ) ( issueDeps [ ] * DependencyInfo , err error ) {
err = db . GetEngine ( ctx ) .
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
Table ( "issue" ) .
Join ( "INNER" , "repository" , "repository.id = issue.repo_id" ) .
Join ( "INNER" , "issue_dependency" , "issue_dependency.dependency_id = issue.id" ) .
2018-07-17 17:23:58 -04:00
Where ( "issue_id = ?" , issue . ID ) .
2021-03-14 14:52:12 -04:00
// sort by repo id then created date, with the issues of the same repo at the beginning of the list
2022-06-04 15:18:50 -04:00
OrderBy ( "CASE WHEN issue.repo_id = ? THEN 0 ELSE issue.repo_id END, issue.created_unix DESC" , issue . RepoID ) .
2018-07-17 17:23:58 -04:00
Find ( & issueDeps )
2021-11-18 03:18:12 -05:00
for _ , depInfo := range issueDeps {
depInfo . Issue . Repo = & depInfo . Repository
}
return issueDeps , err
2018-07-17 17:23:58 -04:00
}
2022-05-20 10:08:52 -04:00
// BlockingDependencies returns all blocking dependencies, aka all other issues a given issue blocks
func ( issue * Issue ) BlockingDependencies ( ctx context . Context ) ( issueDeps [ ] * DependencyInfo , err error ) {
err = db . GetEngine ( ctx ) .
Allow cross-repository dependencies on issues (#7901)
* in progress changes for #7405, added ability to add cross-repo dependencies
* removed unused repolink var
* fixed query that was breaking ci tests; fixed check in issue dependency add so that the id of the issue and dependency is checked rather than the indexes
* reverted removal of string in local files becasue these are done via crowdin, not updated manually
* removed 'Select("issue.*")' from getBlockedByDependencies and getBlockingDependencies based on comments in PR review
* changed getBlockedByDependencies and getBlockingDependencies to use a more xorm-like query, also updated the sidebar as a result
* simplified the getBlockingDependencies and getBlockedByDependencies methods; changed the sidebar to show the dependencies in a different format where you can see the name of the repository
* made some changes to the issue view in the dependencies (issue name on top, repo full name on separate line). Change view of issue in the dependency search results (also showing the full repo name on separate line)
* replace call to FindUserAccessibleRepoIDs with SearchRepositoryByName. The former was hardcoded to use isPrivate = false on the repo search, but this code needed it to be true. The SearchRepositoryByName method is used more in the code including on the user's dashboard
* some more tweaks to the layout of the issues when showing dependencies and in the search box when you add new dependencies
* added Name to the RepositoryMeta struct
* updated swagger doc
* fixed total count for link header on SearchIssues
* fixed indentation
* fixed aligment of remove icon on dependencies in issue sidebar
* removed unnecessary nil check (unnecessary because issue.loadRepo is called prior to this block)
* reverting .css change, somehow missed or forgot that less is used
* updated less file and generated css; updated sidebar template with styles to line up delete and issue index
* added ordering to the blocked by/depends on queries
* fixed sorting in issue dependency search and the depends on/blocks views to show issues from the current repo first, then by created date descending; added a "all cross repository dependencies" setting to allow this feature to be turned off, if turned off, the issue dependency search will work the way it did before (restricted to the current repository)
* re-applied my swagger changes after merge
* fixed split string condition in issue search
* changed ALLOW_CROSS_REPOSITORY_DEPENDENCIES description to sound more global than just the issue dependency search; returning 400 in the cross repo issue search api method if not enabled; fixed bug where the issue count did not respect the state parameter
* when adding a dependency to an issue, added a check to make sure the issue and dependency are in the same repo if cross repo dependencies is not enabled
* updated sortIssuesSession call in PullRequests, another commit moved this method from pull.go to pull_list.go so I had to re-apply my change here
* fixed incorrect setting of user id parameter in search repos call
2019-10-31 01:06:10 -04:00
Table ( "issue" ) .
Join ( "INNER" , "repository" , "repository.id = issue.repo_id" ) .
Join ( "INNER" , "issue_dependency" , "issue_dependency.issue_id = issue.id" ) .
2018-07-17 17:23:58 -04:00
Where ( "dependency_id = ?" , issue . ID ) .
2021-03-14 14:52:12 -04:00
// sort by repo id then created date, with the issues of the same repo at the beginning of the list
2022-06-04 15:18:50 -04:00
OrderBy ( "CASE WHEN issue.repo_id = ? THEN 0 ELSE issue.repo_id END, issue.created_unix DESC" , issue . RepoID ) .
2018-07-17 17:23:58 -04:00
Find ( & issueDeps )
2021-11-18 03:18:12 -05:00
for _ , depInfo := range issueDeps {
depInfo . Issue . Repo = & depInfo . Repository
}
return issueDeps , err
2018-07-17 17:23:58 -04:00
}
2021-01-02 12:04:02 -05:00
// FindAndUpdateIssueMentions finds users mentioned in the given content string, and saves them in the database.
2022-03-29 10:57:33 -04:00
func FindAndUpdateIssueMentions ( ctx context . Context , issue * Issue , doer * user_model . User , content string ) ( mentions [ ] * user_model . User , err error ) {
2021-01-02 12:04:02 -05:00
rawMentions := references . FindAllMentionsMarkdown ( content )
2022-03-29 10:57:33 -04:00
mentions , err = ResolveIssueMentionsByVisibility ( ctx , issue , doer , rawMentions )
2021-01-02 12:04:02 -05:00
if err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "UpdateIssueMentions [%d]: %w" , issue . ID , err )
2021-01-02 12:04:02 -05:00
}
if err = UpdateIssueMentions ( ctx , issue . ID , mentions ) ; err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "UpdateIssueMentions [%d]: %w" , issue . ID , err )
2021-01-02 12:04:02 -05:00
}
2022-06-20 06:02:49 -04:00
return mentions , err
2021-01-02 12:04:02 -05:00
}
2022-03-29 10:57:33 -04:00
// ResolveIssueMentionsByVisibility returns the users mentioned in an issue, removing those that
2019-10-10 12:45:11 -04:00
// don't have access to reading it. Teams are expanded into their users, but organizations are ignored.
2022-03-29 10:57:33 -04:00
func ResolveIssueMentionsByVisibility ( ctx context . Context , issue * Issue , doer * user_model . User , mentions [ ] string ) ( users [ ] * user_model . User , err error ) {
2019-10-10 12:45:11 -04:00
if len ( mentions ) == 0 {
return
}
2022-04-08 05:11:15 -04:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2019-10-10 12:45:11 -04:00
return
}
2020-12-21 10:39:28 -05:00
resolved := make ( map [ string ] bool , 10 )
var mentionTeams [ ] string
2023-02-18 07:11:03 -05:00
if err := issue . Repo . LoadOwner ( ctx ) ; err != nil {
2020-12-21 10:39:28 -05:00
return nil , err
}
repoOwnerIsOrg := issue . Repo . Owner . IsOrganization ( )
if repoOwnerIsOrg {
mentionTeams = make ( [ ] string , 0 , 5 )
}
2019-10-10 12:45:11 -04:00
resolved [ doer . LowerName ] = true
for _ , name := range mentions {
name := strings . ToLower ( name )
if _ , ok := resolved [ name ] ; ok {
continue
}
2020-12-21 10:39:28 -05:00
if repoOwnerIsOrg && strings . Contains ( name , "/" ) {
names := strings . Split ( name , "/" )
if len ( names ) < 2 || names [ 0 ] != issue . Repo . Owner . LowerName {
continue
}
mentionTeams = append ( mentionTeams , names [ 1 ] )
resolved [ name ] = true
} else {
resolved [ name ] = false
}
2019-10-10 12:45:11 -04:00
}
2020-12-21 10:39:28 -05:00
if issue . Repo . Owner . IsOrganization ( ) && len ( mentionTeams ) > 0 {
2022-03-29 02:29:02 -04:00
teams := make ( [ ] * organization . Team , 0 , len ( mentionTeams ) )
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( ctx ) .
2019-10-10 12:45:11 -04:00
Join ( "INNER" , "team_repo" , "team_repo.team_id = team.id" ) .
Where ( "team_repo.repo_id=?" , issue . Repo . ID ) .
2020-12-21 10:39:28 -05:00
In ( "team.lower_name" , mentionTeams ) .
2019-10-10 12:45:11 -04:00
Find ( & teams ) ; err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "find mentioned teams: %w" , err )
2019-10-10 12:45:11 -04:00
}
if len ( teams ) != 0 {
checked := make ( [ ] int64 , 0 , len ( teams ) )
2021-11-09 14:57:58 -05:00
unittype := unit . TypeIssues
2019-10-10 12:45:11 -04:00
if issue . IsPull {
2021-11-09 14:57:58 -05:00
unittype = unit . TypePullRequests
2019-10-10 12:45:11 -04:00
}
for _ , team := range teams {
2022-01-04 22:37:00 -05:00
if team . AccessMode >= perm . AccessModeAdmin {
2019-10-10 12:45:11 -04:00
checked = append ( checked , team . ID )
2020-12-21 10:39:28 -05:00
resolved [ issue . Repo . Owner . LowerName + "/" + team . LowerName ] = true
2019-10-10 12:45:11 -04:00
continue
}
2022-03-29 02:29:02 -04:00
has , err := db . GetEngine ( ctx ) . Get ( & organization . TeamUnit { OrgID : issue . Repo . Owner . ID , TeamID : team . ID , Type : unittype } )
2019-10-10 12:45:11 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "get team units (%d): %w" , team . ID , err )
2019-10-10 12:45:11 -04:00
}
if has {
checked = append ( checked , team . ID )
2020-12-21 10:39:28 -05:00
resolved [ issue . Repo . Owner . LowerName + "/" + team . LowerName ] = true
2019-10-10 12:45:11 -04:00
}
}
if len ( checked ) != 0 {
2021-11-24 04:49:20 -05:00
teamusers := make ( [ ] * user_model . User , 0 , 20 )
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( ctx ) .
2019-10-10 12:45:11 -04:00
Join ( "INNER" , "team_user" , "team_user.uid = `user`.id" ) .
In ( "`team_user`.team_id" , checked ) .
And ( "`user`.is_active = ?" , true ) .
And ( "`user`.prohibit_login = ?" , false ) .
Find ( & teamusers ) ; err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "get teams users: %w" , err )
2019-10-10 12:45:11 -04:00
}
if len ( teamusers ) > 0 {
2021-11-24 04:49:20 -05:00
users = make ( [ ] * user_model . User , 0 , len ( teamusers ) )
2019-10-10 12:45:11 -04:00
for _ , user := range teamusers {
if already , ok := resolved [ user . LowerName ] ; ! ok || ! already {
users = append ( users , user )
resolved [ user . LowerName ] = true
}
}
}
}
}
2020-12-21 10:39:28 -05:00
}
2019-10-10 12:45:11 -04:00
2020-12-21 10:39:28 -05:00
// Remove names already in the list to avoid querying the database if pending names remain
mentionUsers := make ( [ ] string , 0 , len ( resolved ) )
for name , already := range resolved {
if ! already {
mentionUsers = append ( mentionUsers , name )
2019-10-10 12:45:11 -04:00
}
}
2020-12-21 10:39:28 -05:00
if len ( mentionUsers ) == 0 {
return
}
if users == nil {
2021-11-24 04:49:20 -05:00
users = make ( [ ] * user_model . User , 0 , len ( mentionUsers ) )
2020-12-21 10:39:28 -05:00
}
2019-10-10 12:45:11 -04:00
2021-11-24 04:49:20 -05:00
unchecked := make ( [ ] * user_model . User , 0 , len ( mentionUsers ) )
2021-09-23 11:45:36 -04:00
if err := db . GetEngine ( ctx ) .
2019-10-10 12:45:11 -04:00
Where ( "`user`.is_active = ?" , true ) .
And ( "`user`.prohibit_login = ?" , false ) .
2020-12-21 10:39:28 -05:00
In ( "`user`.lower_name" , mentionUsers ) .
2019-10-10 12:45:11 -04:00
Find ( & unchecked ) ; err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "find mentioned users: %w" , err )
2019-10-10 12:45:11 -04:00
}
for _ , user := range unchecked {
if already := resolved [ user . LowerName ] ; already || user . IsOrganization ( ) {
continue
}
// Normal users must have read access to the referencing issue
2022-05-11 06:09:36 -04:00
perm , err := access_model . GetUserRepoPermission ( ctx , issue . Repo , user )
2019-10-10 12:45:11 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return nil , fmt . Errorf ( "GetUserRepoPermission [%d]: %w" , user . ID , err )
2019-10-10 12:45:11 -04:00
}
if ! perm . CanReadIssuesOrPulls ( issue . IsPull ) {
continue
}
users = append ( users , user )
}
2022-06-20 06:02:49 -04:00
return users , err
2019-10-10 12:45:11 -04:00
}
2019-10-14 02:10:42 -04:00
// UpdateIssuesMigrationsByType updates all migrated repositories' issues from gitServiceType to replace originalAuthorID to posterID
2021-11-08 02:04:13 -05:00
func UpdateIssuesMigrationsByType ( gitServiceType api . GitServiceType , originalAuthorID string , posterID int64 ) error {
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . Table ( "issue" ) .
2019-10-14 02:10:42 -04:00
Where ( "repo_id IN (SELECT id FROM repository WHERE original_service_type = ?)" , gitServiceType ) .
And ( "original_author_id = ?" , originalAuthorID ) .
Update ( map [ string ] interface { } {
"poster_id" : posterID ,
"original_author" : "" ,
"original_author_id" : 0 ,
} )
return err
}
2020-01-15 06:14:07 -05:00
2022-06-13 05:37:59 -04:00
func migratedIssueCond ( tp api . GitServiceType ) builder . Cond {
return builder . In ( "issue_id" ,
builder . Select ( "issue.id" ) .
From ( "issue" ) .
InnerJoin ( "repository" , "issue.repo_id = repository.id" ) .
Where ( builder . Eq {
"repository.original_service_type" : tp ,
} ) ,
)
}
2020-01-15 06:14:07 -05:00
// UpdateReactionsMigrationsByType updates all migrated repositories' reactions from gitServiceType to replace originalAuthorID to posterID
2021-11-08 02:04:13 -05:00
func UpdateReactionsMigrationsByType ( gitServiceType api . GitServiceType , originalAuthorID string , userID int64 ) error {
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . Table ( "reaction" ) .
2020-02-17 19:42:13 -05:00
Where ( "original_author_id = ?" , originalAuthorID ) .
And ( migratedIssueCond ( gitServiceType ) ) .
2020-01-15 06:14:07 -05:00
Update ( map [ string ] interface { } {
"user_id" : userID ,
"original_author" : "" ,
"original_author_id" : 0 ,
} )
return err
}
2020-05-29 09:24:15 -04:00
2022-06-13 05:37:59 -04:00
// DeleteIssuesByRepoID deletes issues by repositories id
func DeleteIssuesByRepoID ( ctx context . Context , repoID int64 ) ( attachmentPaths [ ] string , err error ) {
2020-05-29 09:24:15 -04:00
deleteCond := builder . Select ( "id" ) . From ( "issue" ) . Where ( builder . Eq { "issue.repo_id" : repoID } )
2022-05-20 10:08:52 -04:00
sess := db . GetEngine ( ctx )
2021-10-10 18:40:03 -04:00
// Delete content histories
if _ , err = sess . In ( "issue_id" , deleteCond ) .
2022-06-13 05:37:59 -04:00
Delete ( & ContentHistory { } ) ; err != nil {
2021-10-10 18:40:03 -04:00
return
}
2020-05-29 09:24:15 -04:00
// Delete comments and attachments
if _ , err = sess . In ( "issue_id" , deleteCond ) .
Delete ( & Comment { } ) ; err != nil {
return
}
// Dependencies for issues in this repository
if _ , err = sess . In ( "issue_id" , deleteCond ) .
Delete ( & IssueDependency { } ) ; err != nil {
return
}
// Delete dependencies for issues in other repositories
if _ , err = sess . In ( "dependency_id" , deleteCond ) .
Delete ( & IssueDependency { } ) ; err != nil {
return
}
if _ , err = sess . In ( "issue_id" , deleteCond ) .
Delete ( & IssueUser { } ) ; err != nil {
return
}
if _ , err = sess . In ( "issue_id" , deleteCond ) .
2022-06-13 05:37:59 -04:00
Delete ( & Reaction { } ) ; err != nil {
2020-05-29 09:24:15 -04:00
return
}
if _ , err = sess . In ( "issue_id" , deleteCond ) .
Delete ( & IssueWatch { } ) ; err != nil {
return
}
if _ , err = sess . In ( "issue_id" , deleteCond ) .
Delete ( & Stopwatch { } ) ; err != nil {
return
}
if _ , err = sess . In ( "issue_id" , deleteCond ) .
Delete ( & TrackedTime { } ) ; err != nil {
return
}
2020-08-16 23:07:38 -04:00
if _ , err = sess . In ( "issue_id" , deleteCond ) .
2022-03-29 10:16:31 -04:00
Delete ( & project_model . ProjectIssue { } ) ; err != nil {
2020-08-16 23:07:38 -04:00
return
}
2020-09-03 21:36:56 -04:00
if _ , err = sess . In ( "dependent_issue_id" , deleteCond ) .
Delete ( & Comment { } ) ; err != nil {
return
}
2021-11-19 08:39:57 -05:00
var attachments [ ] * repo_model . Attachment
2020-05-29 09:24:15 -04:00
if err = sess . In ( "issue_id" , deleteCond ) .
Find ( & attachments ) ; err != nil {
return
}
2020-08-18 00:23:45 -04:00
2020-05-29 09:24:15 -04:00
for j := range attachments {
2020-08-18 00:23:45 -04:00
attachmentPaths = append ( attachmentPaths , attachments [ j ] . RelativePath ( ) )
2020-05-29 09:24:15 -04:00
}
if _ , err = sess . In ( "issue_id" , deleteCond ) .
2021-11-19 08:39:57 -05:00
Delete ( & repo_model . Attachment { } ) ; err != nil {
2020-05-29 09:24:15 -04:00
return
}
2022-05-20 10:08:52 -04:00
if _ , err = db . DeleteByBean ( ctx , & Issue { RepoID : repoID } ) ; err != nil {
2020-05-29 09:24:15 -04:00
return
}
2022-06-20 06:02:49 -04:00
return attachmentPaths , err
2020-05-29 09:24:15 -04:00
}
2022-02-01 13:20:28 -05:00
// RemapExternalUser ExternalUserRemappable interface
func ( issue * Issue ) RemapExternalUser ( externalName string , externalID , userID int64 ) error {
issue . OriginalAuthor = externalName
issue . OriginalAuthorID = externalID
issue . PosterID = userID
return nil
}
// GetUserID ExternalUserRemappable interface
func ( issue * Issue ) GetUserID ( ) int64 { return issue . PosterID }
// GetExternalName ExternalUserRemappable interface
func ( issue * Issue ) GetExternalName ( ) string { return issue . OriginalAuthor }
// GetExternalID ExternalUserRemappable interface
func ( issue * Issue ) GetExternalID ( ) int64 { return issue . OriginalAuthorID }
2022-06-13 05:37:59 -04:00
// CountOrphanedIssues count issues without a repo
2022-11-19 03:12:33 -05:00
func CountOrphanedIssues ( ctx context . Context ) ( int64 , error ) {
return db . GetEngine ( ctx ) .
Table ( "issue" ) .
2022-06-13 05:37:59 -04:00
Join ( "LEFT" , "repository" , "issue.repo_id=repository.id" ) .
Where ( builder . IsNull { "repository.id" } ) .
Select ( "COUNT(`issue`.`id`)" ) .
Count ( )
}
// DeleteOrphanedIssues delete issues without a repo
2022-11-19 03:12:33 -05:00
func DeleteOrphanedIssues ( ctx context . Context ) error {
2022-06-13 05:37:59 -04:00
var attachmentPaths [ ] string
2023-01-07 20:34:58 -05:00
err := db . WithTx ( ctx , func ( ctx context . Context ) error {
2022-11-19 03:12:33 -05:00
var ids [ ] int64
if err := db . GetEngine ( ctx ) . Table ( "issue" ) . Distinct ( "issue.repo_id" ) .
Join ( "LEFT" , "repository" , "issue.repo_id=repository.id" ) .
Where ( builder . IsNull { "repository.id" } ) . GroupBy ( "issue.repo_id" ) .
Find ( & ids ) ; err != nil {
2022-06-13 05:37:59 -04:00
return err
}
2022-11-19 03:12:33 -05:00
for i := range ids {
paths , err := DeleteIssuesByRepoID ( ctx , ids [ i ] )
if err != nil {
return err
}
attachmentPaths = append ( attachmentPaths , paths ... )
}
return nil
} )
if err != nil {
2022-06-13 05:37:59 -04:00
return err
}
// Remove issue attachment files.
for i := range attachmentPaths {
2022-10-16 19:29:26 -04:00
system_model . RemoveAllWithNotice ( db . DefaultContext , "Delete issue attachment" , attachmentPaths [ i ] )
2022-06-13 05:37:59 -04:00
}
return nil
}
2023-02-15 12:29:13 -05:00
// HasOriginalAuthor returns if an issue was migrated and has an original author.
func ( issue * Issue ) HasOriginalAuthor ( ) bool {
return issue . OriginalAuthor != "" && issue . OriginalAuthorID != 0
}