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-05-07 16:51:14 -04:00
|
|
|
|
2021-09-19 07:49:59 -04:00
|
|
|
"code.gitea.io/gitea/models/db"
|
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"
|
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/log"
|
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"
|
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) {
|
2023-03-28 13:23:25 -04:00
|
|
|
if issue.Repo == nil && issue.RepoID != 0 {
|
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) {
|
2023-03-28 13:23:25 -04:00
|
|
|
if issue.Labels == nil && issue.ID != 0 {
|
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) {
|
2023-03-28 13:23:25 -04:00
|
|
|
if issue.Poster == nil && issue.PosterID != 0 {
|
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 {
|
2023-03-28 13:23:25 -04:00
|
|
|
if issue.PullRequest == nil && issue.ID != 0 {
|
2023-02-20 19:15:49 -05:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
2023-03-28 13:23:25 -04:00
|
|
|
if issue.PullRequest != nil {
|
|
|
|
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) {
|
2023-04-20 02:39:44 -04:00
|
|
|
return issue.loadCommentsByType(ctx, CommentTypeUndefined)
|
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
|
|
|
}
|
|
|
|
|
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))
|
|
|
|
}
|
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetLastEventTimestamp returns the last user visible event timestamp, either the creation of this issue or the close.
|
|
|
|
func (issue *Issue) GetLastEventTimestamp() timeutil.TimeStamp {
|
|
|
|
if issue.IsClosed {
|
|
|
|
return issue.ClosedUnix
|
2015-09-02 16:18:09 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return issue.CreatedUnix
|
|
|
|
}
|
2015-09-02 16:18:09 -04:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// 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"
|
2015-08-25 10:58:34 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return "repo.issues.opened_by"
|
2015-08-25 10:58:34 -04:00
|
|
|
}
|
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetLastComment return last comment for the current issue.
|
|
|
|
func (issue *Issue) GetLastComment() (*Comment, error) {
|
|
|
|
var c Comment
|
|
|
|
exist, err := db.GetEngine(db.DefaultContext).Where("type = ?", CommentTypeComment).
|
|
|
|
And("issue_id = ?", issue.ID).Desc("created_unix").Get(&c)
|
2019-02-21 00:01:28 -05:00
|
|
|
if err != nil {
|
2023-05-18 06:45:25 -04:00
|
|
|
return nil, err
|
2019-02-21 00:01:28 -05:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
if !exist {
|
|
|
|
return nil, nil
|
2021-03-06 10:11:12 -05:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return &c, nil
|
|
|
|
}
|
2019-02-21 00:01:28 -05:00
|
|
|
|
2023-05-18 06:45:25 -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"
|
2019-02-21 00:01:28 -05:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return "repo.issues.opened_by_fake"
|
2019-02-21 00:01:28 -05:00
|
|
|
}
|
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetIssueByIndex returns raw issue without loading attributes by index in a repository.
|
|
|
|
func GetIssueByIndex(repoID, index int64) (*Issue, error) {
|
|
|
|
if index < 1 {
|
|
|
|
return nil, ErrIssueNotExist{}
|
2020-05-16 17:05:19 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
issue := &Issue{
|
|
|
|
RepoID: repoID,
|
|
|
|
Index: index,
|
2020-05-16 17:05:19 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
has, err := db.GetEngine(db.DefaultContext).Get(issue)
|
2020-05-16 17:05:19 -04:00
|
|
|
if err != nil {
|
2023-05-18 06:45:25 -04:00
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrIssueNotExist{0, repoID, index}
|
2020-01-02 02:54:22 -05:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return issue, nil
|
|
|
|
}
|
2020-01-02 02:54:22 -05:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetIssueWithAttrsByIndex returns issue by index in a repository.
|
|
|
|
func GetIssueWithAttrsByIndex(repoID, index int64) (*Issue, error) {
|
|
|
|
issue, err := GetIssueByIndex(repoID, index)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2019-09-20 01:45:38 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return issue, issue.LoadAttributes(db.DefaultContext)
|
|
|
|
}
|
2020-05-16 17:05:19 -04:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetIssueByID returns an issue by given ID.
|
|
|
|
func GetIssueByID(ctx context.Context, id int64) (*Issue, error) {
|
|
|
|
issue := new(Issue)
|
|
|
|
has, err := db.GetEngine(ctx).ID(id).Get(issue)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrIssueNotExist{id, 0, 0}
|
2020-05-16 17:05:19 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return issue, nil
|
2015-10-24 03:36:47 -04:00
|
|
|
}
|
2018-05-01 15:05:28 -04:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetIssueWithAttrsByID returns an issue with attributes by given ID.
|
|
|
|
func GetIssueWithAttrsByID(id int64) (*Issue, error) {
|
|
|
|
issue, err := GetIssueByID(db.DefaultContext, id)
|
2021-11-19 08:39:57 -05:00
|
|
|
if err != nil {
|
2023-05-18 06:45:25 -04:00
|
|
|
return nil, err
|
2018-05-01 15:05:28 -04:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return issue, issue.LoadAttributes(db.DefaultContext)
|
|
|
|
}
|
2018-05-01 15:05:28 -04:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetIssuesByIDs return issues with the given IDs.
|
|
|
|
func GetIssuesByIDs(ctx context.Context, issueIDs []int64) (IssueList, error) {
|
|
|
|
issues := make([]*Issue, 0, 10)
|
|
|
|
return issues, db.GetEngine(ctx).In("id", issueIDs).Find(&issues)
|
|
|
|
}
|
2018-05-01 15:05:28 -04:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// GetIssueIDsByRepoID returns all issue ids by repo id
|
|
|
|
func GetIssueIDsByRepoID(ctx context.Context, repoID int64) ([]int64, error) {
|
|
|
|
ids := make([]int64, 0, 10)
|
|
|
|
err := db.GetEngine(ctx).Table("issue").Cols("id").Where("repo_id = ?", repoID).Find(&ids)
|
|
|
|
return ids, err
|
|
|
|
}
|
2018-05-01 15:05:28 -04:00
|
|
|
|
2023-05-18 06:45:25 -04: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.
|
|
|
|
func GetParticipantsIDsByIssueID(ctx context.Context, issueID int64) ([]int64, error) {
|
|
|
|
userIDs := make([]int64, 0, 5)
|
|
|
|
return userIDs, db.GetEngine(ctx).
|
|
|
|
Table("comment").
|
|
|
|
Cols("poster_id").
|
|
|
|
Where("issue_id = ?", issueID).
|
|
|
|
And("type in (?,?,?)", CommentTypeComment, CommentTypeCode, CommentTypeReview).
|
|
|
|
Distinct("poster_id").
|
|
|
|
Find(&userIDs)
|
2018-05-01 15:05:28 -04:00
|
|
|
}
|
2018-07-17 17:23:58 -04:00
|
|
|
|
2023-05-18 06:45:25 -04:00
|
|
|
// IsUserParticipantsOfIssue return true if user is participants of an issue
|
|
|
|
func IsUserParticipantsOfIssue(user *user_model.User, issue *Issue) bool {
|
|
|
|
userIDs, err := issue.GetParticipantIDsByIssue(db.DefaultContext)
|
|
|
|
if err != nil {
|
|
|
|
log.Error(err.Error())
|
|
|
|
return false
|
2022-02-28 19:20:15 -05:00
|
|
|
}
|
2023-05-18 06:45:25 -04:00
|
|
|
return util.SliceContains(userIDs, user.ID)
|
2022-02-28 19:20:15 -05: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
|
|
|
// 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
|
2023-03-28 13:23:25 -04:00
|
|
|
func (issue *Issue) BlockedByDependencies(ctx context.Context, opts db.ListOptions) (issueDeps []*DependencyInfo, err error) {
|
|
|
|
sess := 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
|
2023-03-28 13:23:25 -04:00
|
|
|
OrderBy("CASE WHEN issue.repo_id = ? THEN 0 ELSE issue.repo_id END, issue.created_unix DESC", issue.RepoID)
|
|
|
|
if opts.Page != 0 {
|
|
|
|
sess = db.SetSessionPagination(sess, &opts)
|
|
|
|
}
|
|
|
|
err = sess.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
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
}
|