2018-08-06 12:43:22 +08:00
// Copyright 2018 The Gitea Authors.
// Copyright 2016 The Gogs Authors.
// All rights reserved.
2022-11-28 02:20:29 +08:00
// SPDX-License-Identifier: MIT
2016-03-06 01:58:51 +08:00
2022-06-13 17:37:59 +08:00
package issues
2016-03-06 01:58:51 +08:00
import (
2021-11-19 21:39:57 +08:00
"context"
2016-03-06 01:58:51 +08:00
"fmt"
2020-06-18 22:07:09 +08:00
"strconv"
"unicode/utf8"
2016-03-06 01:58:51 +08:00
2021-09-19 19:49:59 +08:00
"code.gitea.io/gitea/models/db"
2022-06-12 23:51:54 +08:00
git_model "code.gitea.io/gitea/models/git"
2022-03-29 14:29:02 +08:00
"code.gitea.io/gitea/models/organization"
2022-03-29 22:16:31 +08:00
project_model "code.gitea.io/gitea/models/project"
2021-11-19 21:39:57 +08:00
repo_model "code.gitea.io/gitea/models/repo"
2021-11-24 17:49:20 +08:00
user_model "code.gitea.io/gitea/models/user"
2023-09-09 05:09:23 +08:00
"code.gitea.io/gitea/modules/container"
2019-03-27 17:33:00 +08:00
"code.gitea.io/gitea/modules/git"
2021-07-25 00:03:58 +08:00
"code.gitea.io/gitea/modules/json"
2019-08-15 22:46:21 +08:00
"code.gitea.io/gitea/modules/log"
2019-10-14 06:29:10 +08:00
"code.gitea.io/gitea/modules/references"
2019-10-14 14:10:42 +08:00
"code.gitea.io/gitea/modules/structs"
2019-08-15 22:46:21 +08:00
"code.gitea.io/gitea/modules/timeutil"
2023-08-24 13:06:17 +08:00
"code.gitea.io/gitea/modules/translation"
2022-10-18 13:50:37 +08:00
"code.gitea.io/gitea/modules/util"
2019-08-15 22:46:21 +08:00
2019-06-23 23:22:43 +08:00
"xorm.io/builder"
2019-10-17 17:26:49 +08:00
"xorm.io/xorm"
2016-03-06 01:58:51 +08:00
)
2022-06-13 17:37:59 +08:00
// ErrCommentNotExist represents a "CommentNotExist" kind of error.
type ErrCommentNotExist struct {
ID int64
IssueID int64
}
// IsErrCommentNotExist checks if an error is a ErrCommentNotExist.
func IsErrCommentNotExist ( err error ) bool {
_ , ok := err . ( ErrCommentNotExist )
return ok
}
func ( err ErrCommentNotExist ) Error ( ) string {
return fmt . Sprintf ( "comment does not exist [id: %d, issue_id: %d]" , err . ID , err . IssueID )
}
2022-10-18 13:50:37 +08:00
func ( err ErrCommentNotExist ) Unwrap ( ) error {
return util . ErrNotExist
}
2016-03-06 01:58:51 +08:00
// CommentType defines whether a comment is just a simple comment, an action (like close) or a reference.
type CommentType int
2023-04-20 14:39:44 +08:00
// CommentTypeUndefined is used to search for comments of any type
const CommentTypeUndefined CommentType = - 1
2017-06-21 09:00:44 +08:00
2016-03-06 01:58:51 +08:00
const (
2023-04-20 14:39:44 +08:00
CommentTypeComment CommentType = iota // 0 Plain comment, can be associated with a commit (CommitID > 0) and a line (LineNum > 0)
CommentTypeReopen // 1
CommentTypeClose // 2
CommentTypeIssueRef // 3 References.
CommentTypeCommitRef // 4 Reference from a commit (not part of a pull request)
CommentTypeCommentRef // 5 Reference from a comment
CommentTypePullRef // 6 Reference from a pull request
CommentTypeLabel // 7 Labels changed
CommentTypeMilestone // 8 Milestone changed
CommentTypeAssignees // 9 Assignees changed
CommentTypeChangeTitle // 10 Change Title
CommentTypeDeleteBranch // 11 Delete Branch
CommentTypeStartTracking // 12 Start a stopwatch for time tracking
CommentTypeStopTracking // 13 Stop a stopwatch for time tracking
CommentTypeAddTimeManual // 14 Add time manual for time tracking
CommentTypeCancelTracking // 15 Cancel a stopwatch for time tracking
CommentTypeAddedDeadline // 16 Added a due date
CommentTypeModifiedDeadline // 17 Modified the due date
CommentTypeRemovedDeadline // 18 Removed a due date
CommentTypeAddDependency // 19 Dependency added
CommentTypeRemoveDependency // 20 Dependency removed
CommentTypeCode // 21 Comment a line of code
CommentTypeReview // 22 Reviews a pull request by giving general feedback
CommentTypeLock // 23 Lock an issue, giving only collaborators access
CommentTypeUnlock // 24 Unlocks a previously locked issue
CommentTypeChangeTargetBranch // 25 Change pull request's target branch
CommentTypeDeleteTimeManual // 26 Delete time manual for time tracking
CommentTypeReviewRequest // 27 add or remove Request from one
CommentTypeMergePull // 28 merge pull request
CommentTypePullRequestPush // 29 push to PR head branch
CommentTypeProject // 30 Project changed
CommentTypeProjectBoard // 31 Project board changed
CommentTypeDismissReview // 32 Dismiss Review
CommentTypeChangeIssueRef // 33 Change issue ref
CommentTypePRScheduledToAutoMerge // 34 pr was scheduled to auto merge when checks succeed
CommentTypePRUnScheduledToAutoMerge // 35 pr was un scheduled to auto merge when checks succeed
2023-05-25 21:17:19 +08:00
CommentTypePin // 36 pin Issue
CommentTypeUnpin // 37 unpin Issue
2016-03-06 01:58:51 +08:00
)
2022-01-01 22:12:25 +08:00
var commentStrings = [ ] string {
"comment" ,
"reopen" ,
"close" ,
"issue_ref" ,
"commit_ref" ,
"comment_ref" ,
"pull_ref" ,
"label" ,
"milestone" ,
"assignees" ,
"change_title" ,
"delete_branch" ,
"start_tracking" ,
"stop_tracking" ,
"add_time_manual" ,
"cancel_tracking" ,
"added_deadline" ,
"modified_deadline" ,
"removed_deadline" ,
"add_dependency" ,
"remove_dependency" ,
"code" ,
"review" ,
"lock" ,
"unlock" ,
"change_target_branch" ,
"delete_time_manual" ,
"review_request" ,
"merge_pull" ,
"pull_push" ,
"project" ,
"project_board" ,
"dismiss_review" ,
"change_issue_ref" ,
2022-05-08 01:05:52 +08:00
"pull_scheduled_merge" ,
"pull_cancel_scheduled_merge" ,
2023-05-25 21:17:19 +08:00
"pin" ,
"unpin" ,
2022-01-01 22:12:25 +08:00
}
func ( t CommentType ) String ( ) string {
return commentStrings [ t ]
}
2023-01-19 10:14:56 +08:00
func AsCommentType ( typeName string ) CommentType {
for index , name := range commentStrings {
if typeName == name {
return CommentType ( index )
}
}
2023-04-20 14:39:44 +08:00
return CommentTypeUndefined
}
func ( t CommentType ) HasContentSupport ( ) bool {
switch t {
2023-06-23 18:33:20 +08:00
case CommentTypeComment , CommentTypeCode , CommentTypeReview , CommentTypeDismissReview :
2023-04-20 14:39:44 +08:00
return true
}
return false
}
func ( t CommentType ) HasAttachmentSupport ( ) bool {
switch t {
case CommentTypeComment , CommentTypeCode , CommentTypeReview :
return true
}
return false
2023-01-19 10:14:56 +08:00
}
2023-08-24 13:06:17 +08:00
// RoleInRepo presents the user's participation in the repo
type RoleInRepo string
// RoleDescriptor defines comment "role" tags
type RoleDescriptor struct {
IsPoster bool
RoleInRepo RoleInRepo
}
2016-03-06 01:58:51 +08:00
2021-11-11 14:29:30 +08:00
// Enumerate all the role tags.
2016-03-06 01:58:51 +08:00
const (
2023-08-24 13:06:17 +08:00
RoleRepoOwner RoleInRepo = "owner"
RoleRepoMember RoleInRepo = "member"
RoleRepoCollaborator RoleInRepo = "collaborator"
RoleRepoFirstTimeContributor RoleInRepo = "first_time_contributor"
RoleRepoContributor RoleInRepo = "contributor"
2016-03-06 01:58:51 +08:00
)
2023-08-24 13:06:17 +08:00
// LocaleString returns the locale string name of the role
func ( r RoleInRepo ) LocaleString ( lang translation . Locale ) string {
return lang . Tr ( "repo.issues.role." + string ( r ) )
2021-11-11 14:29:30 +08:00
}
2023-08-24 13:06:17 +08:00
// LocaleHelper returns the locale tooltip of the role
func ( r RoleInRepo ) LocaleHelper ( lang translation . Locale ) string {
return lang . Tr ( "repo.issues.role." + string ( r ) + "_helper" )
2021-11-11 14:29:30 +08:00
}
2016-03-06 01:58:51 +08:00
// Comment represents a comment in commit and issue page.
type Comment struct {
2021-11-24 17:49:20 +08:00
ID int64 ` xorm:"pk autoincr" `
Type CommentType ` xorm:"INDEX" `
PosterID int64 ` xorm:"INDEX" `
Poster * user_model . User ` xorm:"-" `
2019-07-08 10:14:12 +08:00
OriginalAuthor string
OriginalAuthorID int64
2018-07-18 05:23:58 +08:00
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
LabelID int64
2020-10-26 05:49:48 +08:00
Label * Label ` xorm:"-" `
AddedLabels [ ] * Label ` xorm:"-" `
RemovedLabels [ ] * Label ` xorm:"-" `
2020-08-17 11:07:38 +08:00
OldProjectID int64
ProjectID int64
2022-03-29 22:16:31 +08:00
OldProject * project_model . Project ` xorm:"-" `
Project * project_model . Project ` xorm:"-" `
2018-07-18 05:23:58 +08:00
OldMilestoneID int64
MilestoneID int64
2022-06-13 17:37:59 +08:00
OldMilestone * Milestone ` xorm:"-" `
Milestone * Milestone ` xorm:"-" `
2021-02-19 18:52:11 +08:00
TimeID int64
Time * TrackedTime ` xorm:"-" `
2018-07-18 05:23:58 +08:00
AssigneeID int64
RemovedAssignee bool
2022-03-29 14:29:02 +08:00
Assignee * user_model . User ` xorm:"-" `
AssigneeTeamID int64 ` xorm:"NOT NULL DEFAULT 0" `
AssigneeTeam * organization . Team ` xorm:"-" `
2020-04-18 21:50:25 +08:00
ResolveDoerID int64
2021-11-24 17:49:20 +08:00
ResolveDoer * user_model . User ` xorm:"-" `
2018-07-18 05:23:58 +08:00
OldTitle string
NewTitle string
2019-12-16 14:20:25 +08:00
OldRef string
NewRef string
2023-09-29 10:00:14 +08:00
DependentIssueID int64 ` xorm:"index" ` // This is used by issue_service.deleteIssue
2018-07-18 05:23:58 +08:00
DependentIssue * Issue ` xorm:"-" `
2017-02-03 23:09:10 +08:00
2017-02-01 10:36:08 +08:00
CommitID int64
2018-08-06 12:43:22 +08:00
Line int64 // - previous line / + proposed line
TreePath string
2021-08-22 23:33:05 +08:00
Content string ` xorm:"LONGTEXT" `
2016-03-10 08:53:30 +08:00
RenderedContent string ` xorm:"-" `
2018-08-06 12:43:22 +08:00
// Path represents the 4 lines of code cemented by this comment
2020-06-18 22:07:09 +08:00
Patch string ` xorm:"-" `
2021-08-22 23:33:05 +08:00
PatchQuoted string ` xorm:"LONGTEXT patch" `
2018-08-06 12:43:22 +08:00
2019-08-15 22:46:21 +08:00
CreatedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"INDEX updated" `
2016-03-06 01:58:51 +08:00
// Reference issue in commit message
CommitSHA string ` xorm:"VARCHAR(40)" `
2022-06-13 17:37:59 +08:00
Attachments [ ] * repo_model . Attachment ` xorm:"-" `
Reactions ReactionList ` xorm:"-" `
2016-03-06 01:58:51 +08:00
// For view issue page.
2021-11-11 14:29:30 +08:00
ShowRole RoleDescriptor ` xorm:"-" `
2018-08-06 12:43:22 +08:00
Review * Review ` xorm:"-" `
2019-08-05 22:29:40 +08:00
ReviewID int64 ` xorm:"index" `
2018-08-06 12:43:22 +08:00
Invalidated bool
2019-09-20 13:45:38 +08:00
// Reference an issue or pull from another comment, issue or PR
// All information is about the origin of the reference
2019-10-14 06:29:10 +08:00
RefRepoID int64 ` xorm:"index" ` // Repo where the referencing
RefIssueID int64 ` xorm:"index" `
RefCommentID int64 ` xorm:"index" ` // 0 if origin is Issue title or content (or PR's)
2021-07-08 19:38:13 +08:00
RefAction references . XRefAction ` xorm:"SMALLINT" ` // What happens if RefIssueID resolves
2019-09-20 13:45:38 +08:00
RefIsPull bool
2021-12-10 09:27:50 +08:00
RefRepo * repo_model . Repository ` xorm:"-" `
RefIssue * Issue ` xorm:"-" `
RefComment * Comment ` xorm:"-" `
2020-05-20 20:47:24 +08:00
2022-06-12 23:51:54 +08:00
Commits [ ] * git_model . SignCommitWithStatuses ` xorm:"-" `
OldCommit string ` xorm:"-" `
NewCommit string ` xorm:"-" `
CommitsNum int64 ` xorm:"-" `
IsForcePush bool ` xorm:"-" `
2020-05-20 20:47:24 +08:00
}
2021-09-19 19:49:59 +08:00
func init ( ) {
db . RegisterModel ( new ( Comment ) )
}
2020-05-20 20:47:24 +08:00
// PushActionContent is content of push pull comment
type PushActionContent struct {
IsForcePush bool ` json:"is_force_push" `
CommitIDs [ ] string ` json:"commit_ids" `
2016-03-06 01:58:51 +08:00
}
2022-11-19 16:12:33 +08:00
// LoadIssue loads the issue reference for the comment
func ( c * Comment ) LoadIssue ( ctx context . Context ) ( err error ) {
2018-05-16 22:01:55 +08:00
if c . Issue != nil {
return nil
}
2022-06-13 17:37:59 +08:00
c . Issue , err = GetIssueByID ( ctx , c . IssueID )
2022-06-20 18:02:49 +08:00
return err
2018-05-16 22:01:55 +08:00
}
2020-06-18 22:07:09 +08:00
// BeforeInsert will be invoked by XORM before inserting a record
func ( c * Comment ) BeforeInsert ( ) {
c . PatchQuoted = c . Patch
if ! utf8 . ValidString ( c . Patch ) {
c . PatchQuoted = strconv . Quote ( c . Patch )
}
}
// BeforeUpdate will be invoked by XORM before updating a record
func ( c * Comment ) BeforeUpdate ( ) {
c . PatchQuoted = c . Patch
if ! utf8 . ValidString ( c . Patch ) {
c . PatchQuoted = strconv . Quote ( c . Patch )
}
}
// AfterLoad is invoked from XORM after setting the values of all fields of this object.
func ( c * Comment ) AfterLoad ( session * xorm . Session ) {
c . Patch = c . PatchQuoted
if len ( c . PatchQuoted ) > 0 && c . PatchQuoted [ 0 ] == '"' {
unquoted , err := strconv . Unquote ( c . PatchQuoted )
if err == nil {
c . Patch = unquoted
}
}
}
2022-11-19 16:12:33 +08:00
// LoadPoster loads comment poster
func ( c * Comment ) LoadPoster ( ctx context . Context ) ( err error ) {
2019-09-25 01:39:50 +08:00
if c . PosterID <= 0 || c . Poster != nil {
2019-04-18 13:00:03 +08:00
return 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-31 09:45:19 +08:00
c . Poster , err = user_model . GetPossibleUserByID ( ctx , c . PosterID )
2019-04-18 13:00:03 +08:00
if err != nil {
2021-11-24 17:49:20 +08:00
if user_model . IsErrUserNotExist ( err ) {
2019-04-18 13:00:03 +08:00
c . PosterID = - 1
2021-11-24 17:49:20 +08:00
c . Poster = user_model . NewGhostUser ( )
2019-04-18 13:00:03 +08:00
} else {
log . Error ( "getUserByID[%d]: %v" , c . ID , err )
}
}
return err
}
2016-11-28 21:33:09 +08:00
// AfterDelete is invoked from XORM after the object is deleted.
2023-09-15 14:13:19 +08:00
func ( c * Comment ) AfterDelete ( ctx context . Context ) {
2018-06-12 06:54:30 +08:00
if c . ID <= 0 {
return
}
2023-09-15 14:13:19 +08:00
_ , err := repo_model . DeleteAttachmentsByComment ( ctx , c . ID , true )
2016-03-06 01:58:51 +08:00
if err != nil {
log . Info ( "Could not delete files for comment %d on issue #%d: %s" , c . ID , c . IssueID , err )
}
}
2016-12-22 16:29:26 +08:00
// HTMLURL formats a URL-string to the issue-comment
func ( c * Comment ) HTMLURL ( ) string {
2022-11-19 16:12:33 +08:00
err := c . LoadIssue ( db . DefaultContext )
2016-12-22 16:29:26 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2016-12-22 16:29:26 +08:00
return ""
}
2022-04-08 17:11:15 +08:00
err = c . Issue . LoadRepo ( db . DefaultContext )
2018-12-13 23:55:43 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 23:55:43 +08:00
return ""
}
2023-02-07 02:09:18 +08:00
return c . Issue . HTMLURL ( ) + c . hashLink ( )
}
// Link formats a relative URL-string to the issue-comment
func ( c * Comment ) Link ( ) string {
err := c . LoadIssue ( db . DefaultContext )
if err != nil { // Silently dropping errors :unamused:
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
return ""
}
err = c . Issue . LoadRepo ( db . DefaultContext )
if err != nil { // Silently dropping errors :unamused:
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
return ""
}
return c . Issue . Link ( ) + c . hashLink ( )
}
func ( c * Comment ) hashLink ( ) string {
2018-08-06 12:43:22 +08:00
if c . Type == CommentTypeCode {
if c . ReviewID == 0 {
2023-02-07 02:09:18 +08:00
return "/files#" + c . HashTag ( )
2018-08-06 12:43:22 +08:00
}
if c . Review == nil {
if err := c . LoadReview ( ) ; err != nil {
log . Warn ( "LoadReview(%d): %v" , c . ReviewID , err )
2023-02-07 02:09:18 +08:00
return "/files#" + c . HashTag ( )
2018-08-06 12:43:22 +08:00
}
}
if c . Review . Type <= ReviewTypePending {
2023-02-07 02:09:18 +08:00
return "/files#" + c . HashTag ( )
2018-08-06 12:43:22 +08:00
}
}
2023-02-07 02:09:18 +08:00
return "#" + c . HashTag ( )
2016-12-22 16:29:26 +08:00
}
2020-01-09 19:56:32 +08:00
// APIURL formats a API-string to the issue-comment
func ( c * Comment ) APIURL ( ) string {
2022-11-19 16:12:33 +08:00
err := c . LoadIssue ( db . DefaultContext )
2020-01-09 19:56:32 +08:00
if err != nil { // Silently dropping errors :unamused:
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
return ""
}
2022-04-08 17:11:15 +08:00
err = c . Issue . LoadRepo ( db . DefaultContext )
2020-01-09 19:56:32 +08:00
if err != nil { // Silently dropping errors :unamused:
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
return ""
}
2020-01-14 23:37:19 +08:00
return fmt . Sprintf ( "%s/issues/comments/%d" , c . Issue . Repo . APIURL ( ) , c . ID )
2020-01-09 19:56:32 +08:00
}
2016-12-22 16:29:26 +08:00
// IssueURL formats a URL-string to the issue
func ( c * Comment ) IssueURL ( ) string {
2022-11-19 16:12:33 +08:00
err := c . LoadIssue ( db . DefaultContext )
2016-12-22 16:29:26 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2016-12-22 16:29:26 +08:00
return ""
}
2018-05-16 22:01:55 +08:00
if c . Issue . IsPull {
2016-12-22 16:29:26 +08:00
return ""
}
2018-12-13 23:55:43 +08:00
2022-04-08 17:11:15 +08:00
err = c . Issue . LoadRepo ( db . DefaultContext )
2018-12-13 23:55:43 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 23:55:43 +08:00
return ""
}
2018-05-16 22:01:55 +08:00
return c . Issue . HTMLURL ( )
2016-12-22 16:29:26 +08:00
}
// PRURL formats a URL-string to the pull-request
func ( c * Comment ) PRURL ( ) string {
2022-11-19 16:12:33 +08:00
err := c . LoadIssue ( db . DefaultContext )
2016-12-22 16:29:26 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2016-12-22 16:29:26 +08:00
return ""
}
2022-04-08 17:11:15 +08:00
err = c . Issue . LoadRepo ( db . DefaultContext )
2018-12-13 23:55:43 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 23:55:43 +08:00
return ""
}
2018-05-16 22:01:55 +08:00
if ! c . Issue . IsPull {
2016-12-22 16:29:26 +08:00
return ""
}
2018-05-16 22:01:55 +08:00
return c . Issue . HTMLURL ( )
2016-12-22 16:29:26 +08:00
}
2018-05-16 22:01:55 +08:00
// CommentHashTag returns unique hash tag for comment id.
func CommentHashTag ( id int64 ) string {
return fmt . Sprintf ( "issuecomment-%d" , id )
}
2016-03-06 01:58:51 +08:00
// HashTag returns unique hash tag for comment.
func ( c * Comment ) HashTag ( ) string {
2018-05-16 22:01:55 +08:00
return CommentHashTag ( c . ID )
2016-03-06 01:58:51 +08:00
}
// EventTag returns unique event hash tag for comment.
func ( c * Comment ) EventTag ( ) string {
2020-12-25 17:59:32 +08:00
return fmt . Sprintf ( "event-%d" , c . ID )
2016-03-06 01:58:51 +08:00
}
2017-01-30 20:46:45 +08:00
// LoadLabel if comment.Type is CommentTypeLabel, then load Label
func ( c * Comment ) LoadLabel ( ) error {
var label Label
2021-09-23 23:45:36 +08:00
has , err := db . GetEngine ( db . DefaultContext ) . ID ( c . LabelID ) . Get ( & label )
2017-01-30 20:46:45 +08:00
if err != nil {
return err
2017-02-11 20:56:57 +08:00
} else if has {
c . Label = & label
} else {
// Ignore Label is deleted, but not clear this table
log . Warn ( "Commit %d cannot load label %d" , c . ID , c . LabelID )
2017-01-30 20:46:45 +08:00
}
2017-02-11 20:56:57 +08:00
2017-01-30 20:46:45 +08:00
return nil
}
2020-08-17 11:07:38 +08:00
// LoadProject if comment.Type is CommentTypeProject, then load project.
func ( c * Comment ) LoadProject ( ) error {
if c . OldProjectID > 0 {
2022-03-29 22:16:31 +08:00
var oldProject project_model . Project
2021-09-23 23:45:36 +08:00
has , err := db . GetEngine ( db . DefaultContext ) . ID ( c . OldProjectID ) . Get ( & oldProject )
2020-08-17 11:07:38 +08:00
if err != nil {
return err
} else if has {
c . OldProject = & oldProject
}
}
if c . ProjectID > 0 {
2022-03-29 22:16:31 +08:00
var project project_model . Project
2021-09-23 23:45:36 +08:00
has , err := db . GetEngine ( db . DefaultContext ) . ID ( c . ProjectID ) . Get ( & project )
2020-08-17 11:07:38 +08:00
if err != nil {
return err
} else if has {
c . Project = & project
}
}
return nil
}
2017-02-01 10:36:08 +08:00
// LoadMilestone if comment.Type is CommentTypeMilestone, then load milestone
2022-11-19 16:12:33 +08:00
func ( c * Comment ) LoadMilestone ( ctx context . Context ) error {
2017-02-01 10:36:08 +08:00
if c . OldMilestoneID > 0 {
2022-06-13 17:37:59 +08:00
var oldMilestone Milestone
2022-11-19 16:12:33 +08:00
has , err := db . GetEngine ( ctx ) . ID ( c . OldMilestoneID ) . Get ( & oldMilestone )
2017-02-01 10:36:08 +08:00
if err != nil {
return err
2017-06-17 12:51:28 +08:00
} else if has {
c . OldMilestone = & oldMilestone
2017-02-01 10:36:08 +08:00
}
}
if c . MilestoneID > 0 {
2022-06-13 17:37:59 +08:00
var milestone Milestone
2022-11-19 16:12:33 +08:00
has , err := db . GetEngine ( ctx ) . ID ( c . MilestoneID ) . Get ( & milestone )
2017-02-01 10:36:08 +08:00
if err != nil {
return err
2017-06-17 12:51:28 +08:00
} else if has {
c . Milestone = & milestone
2017-02-01 10:36:08 +08:00
}
}
return nil
}
2022-01-19 01:28:38 +08:00
// LoadAttachments loads attachments (it never returns error, the error during `GetAttachmentsByCommentIDCtx` is ignored)
2022-11-19 16:12:33 +08:00
func ( c * Comment ) LoadAttachments ( ctx context . Context ) error {
2018-12-13 23:55:43 +08:00
if len ( c . Attachments ) > 0 {
return nil
}
var err error
2022-11-19 16:12:33 +08:00
c . Attachments , err = repo_model . GetAttachmentsByCommentID ( ctx , c . ID )
2018-12-13 23:55:43 +08:00
if err != nil {
2019-04-02 15:48:31 +08:00
log . Error ( "getAttachmentsByCommentID[%d]: %v" , c . ID , err )
2018-12-13 23:55:43 +08:00
}
return nil
}
2019-10-15 20:19:32 +08:00
// UpdateAttachments update attachments by UUIDs for the comment
func ( c * Comment ) UpdateAttachments ( uuids [ ] string ) error {
2022-11-13 04:18:50 +08:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-11-19 21:39:57 +08:00
if err != nil {
2019-10-15 20:19:32 +08:00
return err
}
2021-11-19 21:39:57 +08:00
defer committer . Close ( )
attachments , err := repo_model . GetAttachmentsByUUIDs ( ctx , uuids )
2019-10-15 20:19:32 +08:00
if err != nil {
2022-10-25 03:29:17 +08:00
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %w" , uuids , err )
2019-10-15 20:19:32 +08:00
}
for i := 0 ; i < len ( attachments ) ; i ++ {
attachments [ i ] . IssueID = c . IssueID
attachments [ i ] . CommentID = c . ID
2022-05-20 22:08:52 +08:00
if err := repo_model . UpdateAttachment ( ctx , attachments [ i ] ) ; err != nil {
2022-10-25 03:29:17 +08:00
return fmt . Errorf ( "update attachment [id: %d]: %w" , attachments [ i ] . ID , err )
2019-10-15 20:19:32 +08:00
}
}
2021-11-19 21:39:57 +08:00
return committer . Commit ( )
2019-10-15 20:19:32 +08:00
}
2020-10-13 03:55:13 +08:00
// LoadAssigneeUserAndTeam if comment.Type is CommentTypeAssignees, then load assignees
func ( c * Comment ) LoadAssigneeUserAndTeam ( ) error {
2017-02-03 23:09:10 +08:00
var err error
2020-10-13 03:55:13 +08:00
if c . AssigneeID > 0 && c . Assignee == nil {
2022-12-03 10:48:26 +08:00
c . Assignee , err = user_model . GetUserByID ( db . DefaultContext , c . AssigneeID )
2017-02-03 23:09:10 +08:00
if err != nil {
2021-11-24 17:49:20 +08:00
if ! user_model . IsErrUserNotExist ( err ) {
2018-01-07 17:13:10 +08:00
return err
}
2021-11-24 17:49:20 +08:00
c . Assignee = user_model . NewGhostUser ( )
2017-02-03 23:09:10 +08:00
}
2020-10-13 03:55:13 +08:00
} else if c . AssigneeTeamID > 0 && c . AssigneeTeam == nil {
2022-11-19 16:12:33 +08:00
if err = c . LoadIssue ( db . DefaultContext ) ; err != nil {
2020-10-13 03:55:13 +08:00
return err
}
2022-04-08 17:11:15 +08:00
if err = c . Issue . LoadRepo ( db . DefaultContext ) ; err != nil {
2020-10-13 03:55:13 +08:00
return err
}
2023-02-18 20:11:03 +08:00
if err = c . Issue . Repo . LoadOwner ( db . DefaultContext ) ; err != nil {
2020-10-13 03:55:13 +08:00
return err
}
if c . Issue . Repo . Owner . IsOrganization ( ) {
2022-05-20 22:08:52 +08:00
c . AssigneeTeam , err = organization . GetTeamByID ( db . DefaultContext , c . AssigneeTeamID )
2022-03-29 14:29:02 +08:00
if err != nil && ! organization . IsErrTeamNotExist ( err ) {
2020-10-13 03:55:13 +08:00
return err
}
}
2017-02-03 23:09:10 +08:00
}
return nil
}
2020-04-18 21:50:25 +08:00
// LoadResolveDoer if comment.Type is CommentTypeCode and ResolveDoerID not zero, then load resolveDoer
func ( c * Comment ) LoadResolveDoer ( ) ( err error ) {
if c . ResolveDoerID == 0 || c . Type != CommentTypeCode {
return nil
}
2022-12-03 10:48:26 +08:00
c . ResolveDoer , err = user_model . GetUserByID ( db . DefaultContext , c . ResolveDoerID )
2020-04-18 21:50:25 +08:00
if err != nil {
2021-11-24 17:49:20 +08:00
if user_model . IsErrUserNotExist ( err ) {
c . ResolveDoer = user_model . NewGhostUser ( )
2020-04-18 21:50:25 +08:00
err = nil
}
}
2022-06-20 18:02:49 +08:00
return err
2020-04-18 21:50:25 +08:00
}
// IsResolved check if an code comment is resolved
func ( c * Comment ) IsResolved ( ) bool {
return c . ResolveDoerID != 0 && c . Type == CommentTypeCode
}
2018-07-18 05:23:58 +08:00
// LoadDepIssueDetails loads Dependent Issue Details
func ( c * Comment ) LoadDepIssueDetails ( ) ( err error ) {
if c . DependentIssueID <= 0 || c . DependentIssue != nil {
return nil
}
2022-06-13 17:37:59 +08:00
c . DependentIssue , err = GetIssueByID ( db . DefaultContext , c . DependentIssueID )
2018-07-18 05:23:58 +08:00
return err
}
2021-02-19 18:52:11 +08:00
// LoadTime loads the associated time for a CommentTypeAddTimeManual
func ( c * Comment ) LoadTime ( ) error {
if c . Time != nil || c . TimeID == 0 {
return nil
}
var err error
c . Time , err = GetTrackedTimeByID ( c . TimeID )
return err
}
2022-03-31 17:20:39 +08:00
func ( c * Comment ) loadReactions ( ctx context . Context , repo * repo_model . Repository ) ( err error ) {
2017-12-04 07:14:26 +08:00
if c . Reactions != nil {
return nil
}
2022-06-13 17:37:59 +08:00
c . Reactions , _ , err = FindReactions ( ctx , FindReactionsOptions {
2017-12-04 07:14:26 +08:00
IssueID : c . IssueID ,
CommentID : c . ID ,
} )
if err != nil {
return err
}
// Load reaction user data
2022-03-31 17:20:39 +08:00
if _ , err := c . Reactions . LoadUsers ( ctx , repo ) ; err != nil {
2017-12-04 07:14:26 +08:00
return err
}
return nil
}
// LoadReactions loads comment reactions
2021-12-10 09:27:50 +08:00
func ( c * Comment ) LoadReactions ( repo * repo_model . Repository ) error {
2022-03-31 17:20:39 +08:00
return c . loadReactions ( db . DefaultContext , repo )
2017-12-04 07:14:26 +08:00
}
2022-05-20 22:08:52 +08:00
func ( c * Comment ) loadReview ( ctx context . Context ) ( err error ) {
2018-12-13 23:55:43 +08:00
if c . Review == nil {
2022-05-20 22:08:52 +08:00
if c . Review , err = GetReviewByID ( ctx , c . ReviewID ) ; err != nil {
2018-12-13 23:55:43 +08:00
return err
}
2018-08-06 12:43:22 +08:00
}
2019-05-06 20:09:31 +08:00
c . Review . Issue = c . Issue
2018-08-06 12:43:22 +08:00
return nil
}
// LoadReview loads the associated review
func ( c * Comment ) LoadReview ( ) error {
2022-05-20 22:08:52 +08:00
return c . loadReview ( db . DefaultContext )
2018-08-06 12:43:22 +08:00
}
// DiffSide returns "previous" if Comment.Line is a LOC of the previous changes and "proposed" if it is a LOC of the proposed changes.
func ( c * Comment ) DiffSide ( ) string {
if c . Line < 0 {
return "previous"
}
return "proposed"
}
// UnsignedLine returns the LOC of the code comment without + or -
func ( c * Comment ) UnsignedLine ( ) uint64 {
if c . Line < 0 {
return uint64 ( c . Line * - 1 )
}
return uint64 ( c . Line )
}
2023-02-07 02:09:18 +08:00
// CodeCommentLink returns the url to a comment in code
func ( c * Comment ) CodeCommentLink ( ) string {
2022-11-19 16:12:33 +08:00
err := c . LoadIssue ( db . DefaultContext )
2018-08-06 12:43:22 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2018-08-06 12:43:22 +08:00
return ""
}
2022-04-08 17:11:15 +08:00
err = c . Issue . LoadRepo ( db . DefaultContext )
2018-12-13 23:55:43 +08:00
if err != nil { // Silently dropping errors :unamused:
2019-04-02 15:48:31 +08:00
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 23:55:43 +08:00
return ""
}
2023-02-07 02:09:18 +08:00
return fmt . Sprintf ( "%s/files#%s" , c . Issue . Link ( ) , c . HashTag ( ) )
2018-08-06 12:43:22 +08:00
}
2020-05-20 20:47:24 +08:00
// LoadPushCommits Load push commits
2022-01-20 07:26:57 +08:00
func ( c * Comment ) LoadPushCommits ( ctx context . Context ) ( err error ) {
2022-01-22 01:59:26 +08:00
if c . Content == "" || c . Commits != nil || c . Type != CommentTypePullRequestPush {
2020-05-20 20:47:24 +08:00
return nil
}
var data PushActionContent
err = json . Unmarshal ( [ ] byte ( c . Content ) , & data )
if err != nil {
2023-07-09 19:58:06 +08:00
return err
2020-05-20 20:47:24 +08:00
}
c . IsForcePush = data . IsForcePush
if c . IsForcePush {
if len ( data . CommitIDs ) != 2 {
return nil
}
c . OldCommit = data . CommitIDs [ 0 ]
c . NewCommit = data . CommitIDs [ 1 ]
} else {
repoPath := c . Issue . Repo . RepoPath ( )
2022-01-20 07:26:57 +08:00
gitRepo , closer , err := git . RepositoryFromContextOrOpen ( ctx , repoPath )
2020-05-20 20:47:24 +08:00
if err != nil {
return err
}
2022-01-20 07:26:57 +08:00
defer closer . Close ( )
2020-05-20 20:47:24 +08:00
2023-01-09 11:50:54 +08:00
c . Commits = git_model . ConvertFromGitCommit ( ctx , gitRepo . GetCommitsFromIDs ( data . CommitIDs ) , c . Issue . Repo )
2021-08-10 02:08:51 +08:00
c . CommitsNum = int64 ( len ( c . Commits ) )
2020-05-20 20:47:24 +08:00
}
return err
}
2022-12-10 10:46:31 +08:00
// CreateComment creates comment with context
func CreateComment ( ctx context . Context , opts * CreateCommentOptions ) ( _ * Comment , err error ) {
2023-08-04 21:34:34 +08:00
ctx , committer , err := db . TxContext ( ctx )
if err != nil {
return nil , err
}
defer committer . Close ( )
2021-11-19 21:39:57 +08:00
e := db . GetEngine ( ctx )
2017-01-30 20:46:45 +08:00
var LabelID int64
if opts . Label != nil {
LabelID = opts . Label . ID
}
2018-07-18 05:23:58 +08:00
2016-03-06 01:58:51 +08:00
comment := & Comment {
2018-07-18 05:23:58 +08:00
Type : opts . Type ,
PosterID : opts . Doer . ID ,
Poster : opts . Doer ,
IssueID : opts . Issue . ID ,
LabelID : LabelID ,
OldMilestoneID : opts . OldMilestoneID ,
MilestoneID : opts . MilestoneID ,
2020-08-17 11:07:38 +08:00
OldProjectID : opts . OldProjectID ,
ProjectID : opts . ProjectID ,
2021-02-19 18:52:11 +08:00
TimeID : opts . TimeID ,
2018-07-18 05:23:58 +08:00
RemovedAssignee : opts . RemovedAssignee ,
AssigneeID : opts . AssigneeID ,
2020-10-13 03:55:13 +08:00
AssigneeTeamID : opts . AssigneeTeamID ,
2018-07-18 05:23:58 +08:00
CommitID : opts . CommitID ,
CommitSHA : opts . CommitSHA ,
Line : opts . LineNum ,
Content : opts . Content ,
OldTitle : opts . OldTitle ,
NewTitle : opts . NewTitle ,
2019-12-16 14:20:25 +08:00
OldRef : opts . OldRef ,
NewRef : opts . NewRef ,
2018-07-18 05:23:58 +08:00
DependentIssueID : opts . DependentIssueID ,
2018-08-06 12:43:22 +08:00
TreePath : opts . TreePath ,
ReviewID : opts . ReviewID ,
Patch : opts . Patch ,
2019-09-20 13:45:38 +08:00
RefRepoID : opts . RefRepoID ,
RefIssueID : opts . RefIssueID ,
RefCommentID : opts . RefCommentID ,
RefAction : opts . RefAction ,
RefIsPull : opts . RefIsPull ,
2020-05-20 20:47:24 +08:00
IsForcePush : opts . IsForcePush ,
2020-11-09 14:15:09 +08:00
Invalidated : opts . Invalidated ,
2016-03-06 01:58:51 +08:00
}
if _ , err = e . Insert ( comment ) ; err != nil {
return nil , err
}
2023-02-18 20:11:03 +08:00
if err = opts . Repo . LoadOwner ( ctx ) ; err != nil {
2017-01-30 20:46:45 +08:00
return nil , err
}
2021-11-19 21:39:57 +08:00
if err = updateCommentInfos ( ctx , opts , comment ) ; err != nil {
2019-11-06 21:39:29 +08:00
return nil , err
}
2022-06-13 17:37:59 +08:00
if err = comment . AddCrossReferences ( ctx , opts . Doer , false ) ; err != nil {
2019-09-20 13:45:38 +08:00
return nil , err
}
2023-08-04 21:34:34 +08:00
if err = committer . Commit ( ) ; err != nil {
return nil , err
}
2018-08-06 12:43:22 +08:00
return comment , nil
}
2021-11-19 21:39:57 +08:00
func updateCommentInfos ( ctx context . Context , opts * CreateCommentOptions , comment * Comment ) ( err error ) {
2016-03-06 01:58:51 +08:00
// Check comment type.
switch opts . Type {
2018-08-06 12:43:22 +08:00
case CommentTypeCode :
if comment . ReviewID != 0 {
if comment . Review == nil {
2022-05-20 22:08:52 +08:00
if err := comment . loadReview ( ctx ) ; err != nil {
2018-08-06 12:43:22 +08:00
return err
}
}
if comment . Review . Type <= ReviewTypePending {
return nil
}
}
fallthrough
2016-11-08 00:30:04 +08:00
case CommentTypeComment :
2022-05-20 22:08:52 +08:00
if _ , err = db . Exec ( ctx , "UPDATE `issue` SET num_comments=num_comments+1 WHERE id=?" , opts . Issue . ID ) ; err != nil {
2018-08-06 12:43:22 +08:00
return err
2016-03-06 01:58:51 +08:00
}
2022-01-14 00:50:43 +08:00
fallthrough
case CommentTypeReview :
2016-03-06 01:58:51 +08:00
// Check attachments
2021-11-19 21:39:57 +08:00
attachments , err := repo_model . GetAttachmentsByUUIDs ( ctx , opts . Attachments )
2019-12-11 08:01:52 +08:00
if err != nil {
2022-10-25 03:29:17 +08:00
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %w" , opts . Attachments , err )
2016-03-06 01:58:51 +08:00
}
for i := range attachments {
attachments [ i ] . IssueID = opts . Issue . ID
attachments [ i ] . CommentID = comment . ID
// No assign value could be 0, so ignore AllCols().
2022-05-20 22:08:52 +08:00
if _ , err = db . GetEngine ( ctx ) . ID ( attachments [ i ] . ID ) . Update ( attachments [ i ] ) ; err != nil {
2022-10-25 03:29:17 +08:00
return fmt . Errorf ( "update attachment [%d]: %w" , attachments [ i ] . ID , err )
2016-03-06 01:58:51 +08:00
}
}
2022-12-09 14:35:56 +08:00
comment . Attachments = attachments
2019-11-06 21:39:29 +08:00
case CommentTypeReopen , CommentTypeClose :
2022-10-25 20:47:46 +08:00
if err = repo_model . UpdateRepoIssueNumbers ( ctx , opts . Issue . RepoID , opts . Issue . IsPull , true ) ; err != nil {
2019-11-06 21:39:29 +08:00
return err
}
}
// update the issue's updated_unix column
2022-04-08 17:11:15 +08:00
return UpdateIssueCols ( ctx , opts . Issue , "updated_unix" )
2019-11-06 21:39:29 +08:00
}
2016-03-06 01:58:51 +08:00
2021-11-24 17:49:20 +08:00
func createDeadlineComment ( ctx context . Context , doer * user_model . User , issue * Issue , newDeadlineUnix timeutil . TimeStamp ) ( * Comment , error ) {
2018-05-02 03:05:28 +08:00
var content string
var commentType CommentType
// newDeadline = 0 means deleting
if newDeadlineUnix == 0 {
commentType = CommentTypeRemovedDeadline
content = issue . DeadlineUnix . Format ( "2006-01-02" )
} else if issue . DeadlineUnix == 0 {
// Check if the new date was added or modified
// If the actual deadline is 0 => deadline added
commentType = CommentTypeAddedDeadline
content = newDeadlineUnix . Format ( "2006-01-02" )
} else { // Otherwise modified
commentType = CommentTypeModifiedDeadline
content = newDeadlineUnix . Format ( "2006-01-02" ) + "|" + issue . DeadlineUnix . Format ( "2006-01-02" )
}
2022-04-08 17:11:15 +08:00
if err := issue . LoadRepo ( ctx ) ; err != nil {
2018-12-27 23:02:43 +08:00
return nil , err
}
2021-03-15 02:52:12 +08:00
opts := & CreateCommentOptions {
2018-05-02 03:05:28 +08:00
Type : commentType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
Content : content ,
2019-12-01 10:44:39 +08:00
}
2022-12-10 10:46:31 +08:00
comment , err := CreateComment ( ctx , opts )
2019-12-01 10:44:39 +08:00
if err != nil {
return nil , err
}
2019-12-02 22:43:39 +08:00
return comment , nil
2018-05-02 03:05:28 +08:00
}
2018-07-18 05:23:58 +08:00
// Creates issue dependency comment
2021-11-24 17:49:20 +08:00
func createIssueDependencyComment ( ctx context . Context , doer * user_model . User , issue , dependentIssue * Issue , add bool ) ( err error ) {
2018-07-18 05:23:58 +08:00
cType := CommentTypeAddDependency
if ! add {
cType = CommentTypeRemoveDependency
}
2022-04-08 17:11:15 +08:00
if err = issue . LoadRepo ( ctx ) ; err != nil {
2023-07-09 19:58:06 +08:00
return err
2019-01-27 19:31:40 +08:00
}
2018-07-18 05:23:58 +08:00
// Make two comments, one in each issue
2021-03-15 02:52:12 +08:00
opts := & CreateCommentOptions {
2018-07-18 05:23:58 +08:00
Type : cType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
DependentIssueID : dependentIssue . ID ,
2019-12-01 10:44:39 +08:00
}
2022-12-10 10:46:31 +08:00
if _ , err = CreateComment ( ctx , opts ) ; err != nil {
2023-07-09 19:58:06 +08:00
return err
2018-07-18 05:23:58 +08:00
}
2019-12-01 10:44:39 +08:00
opts = & CreateCommentOptions {
2018-07-18 05:23:58 +08:00
Type : cType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : dependentIssue ,
DependentIssueID : issue . ID ,
2019-12-01 10:44:39 +08:00
}
2022-12-10 10:46:31 +08:00
_ , err = CreateComment ( ctx , opts )
2022-06-20 18:02:49 +08:00
return err
2018-07-18 05:23:58 +08:00
}
2016-11-28 21:33:09 +08:00
// CreateCommentOptions defines options for creating comment
2016-03-06 01:58:51 +08:00
type CreateCommentOptions struct {
Type CommentType
2021-11-24 17:49:20 +08:00
Doer * user_model . User
2021-12-10 09:27:50 +08:00
Repo * repo_model . Repository
2016-03-06 01:58:51 +08:00
Issue * Issue
2017-01-30 20:46:45 +08:00
Label * Label
2016-03-06 01:58:51 +08:00
2018-07-18 05:23:58 +08:00
DependentIssueID int64
OldMilestoneID int64
MilestoneID int64
2020-08-17 11:07:38 +08:00
OldProjectID int64
ProjectID int64
2021-02-19 18:52:11 +08:00
TimeID int64
2018-07-18 05:23:58 +08:00
AssigneeID int64
2020-10-13 03:55:13 +08:00
AssigneeTeamID int64
2018-07-18 05:23:58 +08:00
RemovedAssignee bool
OldTitle string
NewTitle string
2019-12-16 14:20:25 +08:00
OldRef string
NewRef string
2018-07-18 05:23:58 +08:00
CommitID int64
CommitSHA string
2018-08-06 12:43:22 +08:00
Patch string
2018-07-18 05:23:58 +08:00
LineNum int64
2018-08-06 12:43:22 +08:00
TreePath string
ReviewID int64
2018-07-18 05:23:58 +08:00
Content string
Attachments [ ] string // UUIDs of attachments
2019-09-20 13:45:38 +08:00
RefRepoID int64
RefIssueID int64
RefCommentID int64
2019-10-14 06:29:10 +08:00
RefAction references . XRefAction
2019-09-20 13:45:38 +08:00
RefIsPull bool
2020-05-20 20:47:24 +08:00
IsForcePush bool
2020-11-09 14:15:09 +08:00
Invalidated bool
2016-03-06 01:58:51 +08:00
}
// GetCommentByID returns the comment by given ID.
2022-05-20 22:08:52 +08:00
func GetCommentByID ( ctx context . Context , id int64 ) ( * Comment , error ) {
2016-03-06 01:58:51 +08:00
c := new ( Comment )
2022-05-20 22:08:52 +08:00
has , err := db . GetEngine ( ctx ) . ID ( id ) . Get ( c )
2016-03-06 01:58:51 +08:00
if err != nil {
return nil , err
} else if ! has {
2016-08-27 04:40:53 +08:00
return nil , ErrCommentNotExist { id , 0 }
2016-03-06 01:58:51 +08:00
}
return c , nil
}
2017-06-21 09:00:44 +08:00
// FindCommentsOptions describes the conditions to Find comments
type FindCommentsOptions struct {
2021-09-24 19:32:56 +08:00
db . ListOptions
2023-01-18 05:03:44 +08:00
RepoID int64
IssueID int64
ReviewID int64
Since int64
Before int64
Line int64
TreePath string
Type CommentType
IssueIDs [ ] int64
Invalidated util . OptionalBool
2017-06-21 09:00:44 +08:00
}
2023-01-18 05:03:44 +08:00
// ToConds implements FindOptions interface
func ( opts * FindCommentsOptions ) ToConds ( ) builder . Cond {
2021-03-15 02:52:12 +08:00
cond := builder . NewCond ( )
2017-06-21 09:00:44 +08:00
if opts . RepoID > 0 {
cond = cond . And ( builder . Eq { "issue.repo_id" : opts . RepoID } )
2016-08-27 04:40:53 +08:00
}
2017-06-21 09:00:44 +08:00
if opts . IssueID > 0 {
cond = cond . And ( builder . Eq { "comment.issue_id" : opts . IssueID } )
2023-01-18 05:03:44 +08:00
} else if len ( opts . IssueIDs ) > 0 {
cond = cond . And ( builder . In ( "comment.issue_id" , opts . IssueIDs ) )
2017-06-21 09:00:44 +08:00
}
2018-08-06 12:43:22 +08:00
if opts . ReviewID > 0 {
cond = cond . And ( builder . Eq { "comment.review_id" : opts . ReviewID } )
}
2017-06-21 09:00:44 +08:00
if opts . Since > 0 {
cond = cond . And ( builder . Gte { "comment.updated_unix" : opts . Since } )
}
2020-01-14 00:02:24 +08:00
if opts . Before > 0 {
cond = cond . And ( builder . Lte { "comment.updated_unix" : opts . Before } )
}
2023-04-20 14:39:44 +08:00
if opts . Type != CommentTypeUndefined {
2017-06-21 09:00:44 +08:00
cond = cond . And ( builder . Eq { "comment.type" : opts . Type } )
}
2021-01-09 05:49:55 +08:00
if opts . Line != 0 {
2020-11-09 14:15:09 +08:00
cond = cond . And ( builder . Eq { "comment.line" : opts . Line } )
}
if len ( opts . TreePath ) > 0 {
cond = cond . And ( builder . Eq { "comment.tree_path" : opts . TreePath } )
}
2023-01-18 05:03:44 +08:00
if ! opts . Invalidated . IsNone ( ) {
cond = cond . And ( builder . Eq { "comment.invalidated" : opts . Invalidated . IsTrue ( ) } )
}
2017-06-21 09:00:44 +08:00
return cond
2016-08-27 04:40:53 +08:00
}
2022-05-20 22:08:52 +08:00
// FindComments returns all comments according options
2023-05-21 20:48:28 +08:00
func FindComments ( ctx context . Context , opts * FindCommentsOptions ) ( CommentList , error ) {
2016-12-22 16:29:26 +08:00
comments := make ( [ ] * Comment , 0 , 10 )
2023-01-18 05:03:44 +08:00
sess := db . GetEngine ( ctx ) . Where ( opts . ToConds ( ) )
2017-06-21 09:00:44 +08:00
if opts . RepoID > 0 {
sess . Join ( "INNER" , "issue" , "issue.id = comment.issue_id" )
2016-12-22 16:29:26 +08:00
}
2020-01-25 03:00:29 +08:00
if opts . Page != 0 {
2021-09-24 19:32:56 +08:00
sess = db . SetSessionPagination ( sess , opts )
2020-01-25 03:00:29 +08:00
}
2020-11-09 14:15:09 +08:00
// WARNING: If you change this order you will need to fix createCodeComment
2017-06-21 09:00:44 +08:00
return comments , sess .
Asc ( "comment.created_unix" ) .
2017-11-03 11:11:42 +08:00
Asc ( "comment.id" ) .
2017-06-21 09:00:44 +08:00
Find ( & comments )
2016-12-22 16:29:26 +08:00
}
2021-08-12 20:43:08 +08:00
// CountComments count all comments according options by ignoring pagination
func CountComments ( opts * FindCommentsOptions ) ( int64 , error ) {
2023-01-18 05:03:44 +08:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( opts . ToConds ( ) )
2021-08-12 20:43:08 +08:00
if opts . RepoID > 0 {
sess . Join ( "INNER" , "issue" , "issue.id = comment.issue_id" )
}
return sess . Count ( & Comment { } )
}
2023-01-18 05:03:44 +08:00
// UpdateCommentInvalidate updates comment invalidated column
func UpdateCommentInvalidate ( ctx context . Context , c * Comment ) error {
_ , err := db . GetEngine ( ctx ) . ID ( c . ID ) . Cols ( "invalidated" ) . Update ( c )
return err
}
2016-03-06 01:58:51 +08:00
// UpdateComment updates information of comment.
2021-11-24 17:49:20 +08:00
func UpdateComment ( c * Comment , doer * user_model . User ) error {
2022-11-13 04:18:50 +08:00
ctx , committer , err := db . TxContext ( db . DefaultContext )
2021-11-19 21:39:57 +08:00
if err != nil {
2017-09-17 04:16:21 +08:00
return err
}
2021-11-19 21:39:57 +08:00
defer committer . Close ( )
sess := db . GetEngine ( ctx )
2018-05-16 22:01:55 +08:00
2019-09-20 13:45:38 +08:00
if _ , err := sess . ID ( c . ID ) . AllCols ( ) . Update ( c ) ; err != nil {
2018-12-13 23:55:43 +08:00
return err
}
2022-11-19 16:12:33 +08:00
if err := c . LoadIssue ( ctx ) ; err != nil {
2018-05-16 22:01:55 +08:00
return err
}
2022-06-13 17:37:59 +08:00
if err := c . AddCrossReferences ( ctx , doer , true ) ; err != nil {
2019-09-20 13:45:38 +08:00
return err
}
2021-11-19 21:39:57 +08:00
if err := committer . Commit ( ) ; err != nil {
2022-10-25 03:29:17 +08:00
return fmt . Errorf ( "Commit: %w" , err )
2019-09-20 13:45:38 +08:00
}
2018-05-16 22:01:55 +08:00
2017-09-17 04:16:21 +08:00
return nil
2016-03-06 01:58:51 +08:00
}
2016-07-26 02:48:17 +08:00
2017-01-25 10:43:02 +08:00
// DeleteComment deletes the comment
2022-06-13 17:37:59 +08:00
func DeleteComment ( ctx context . Context , comment * Comment ) error {
2022-03-31 17:20:39 +08:00
e := db . GetEngine ( ctx )
2022-03-01 08:20:15 +08:00
if _ , err := e . ID ( comment . ID ) . NoAutoCondition ( ) . Delete ( comment ) ; err != nil {
2016-07-26 02:48:17 +08:00
return err
}
2022-06-13 17:37:59 +08:00
if _ , err := db . DeleteByBean ( ctx , & ContentHistory {
2021-10-11 06:40:03 +08:00
CommentID : comment . ID ,
} ) ; err != nil {
return err
}
2016-11-08 00:30:04 +08:00
if comment . Type == CommentTypeComment {
2022-03-18 06:04:09 +08:00
if _ , err := e . ID ( comment . IssueID ) . Decr ( "num_comments" ) . Update ( new ( Issue ) ) ; err != nil {
2016-07-26 02:48:17 +08:00
return err
}
}
2022-06-13 17:37:59 +08:00
if _ , err := e . Table ( "action" ) .
Where ( "comment_id = ?" , comment . ID ) .
2023-07-05 02:36:08 +08:00
Update ( map [ string ] any {
2022-06-13 17:37:59 +08:00
"is_deleted" : true ,
} ) ; err != nil {
2017-07-04 09:30:41 +08:00
return err
}
2016-07-26 02:48:17 +08:00
2022-05-20 22:08:52 +08:00
if err := comment . neuterCrossReferences ( ctx ) ; err != nil {
2019-09-20 13:45:38 +08:00
return err
}
2022-06-13 17:37:59 +08:00
return DeleteReaction ( ctx , & ReactionOptions { CommentID : comment . ID } )
2016-07-26 02:48:17 +08:00
}
2018-08-06 12:43:22 +08:00
2019-10-14 14:10:42 +08:00
// UpdateCommentsMigrationsByType updates comments' migrations information via given git service type and original id and poster id
2019-10-17 10:06:28 +08:00
func UpdateCommentsMigrationsByType ( tp structs . GitServiceType , originalAuthorID string , posterID int64 ) error {
2021-09-23 23:45:36 +08:00
_ , err := db . GetEngine ( db . DefaultContext ) . Table ( "comment" ) .
2019-10-14 14:10:42 +08:00
Where ( 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 ,
} ) ,
) ) .
And ( "comment.original_author_id = ?" , originalAuthorID ) .
2023-07-05 02:36:08 +08:00
Update ( map [ string ] any {
2019-10-14 14:10:42 +08:00
"poster_id" : posterID ,
"original_author" : "" ,
"original_author_id" : 0 ,
} )
return err
}
2020-05-20 20:47:24 +08:00
2022-05-08 21:46:34 +08:00
// CreateAutoMergeComment is a internal function, only use it for CommentTypePRScheduledToAutoMerge and CommentTypePRUnScheduledToAutoMerge CommentTypes
func CreateAutoMergeComment ( ctx context . Context , typ CommentType , pr * PullRequest , doer * user_model . User ) ( comment * Comment , err error ) {
if typ != CommentTypePRScheduledToAutoMerge && typ != CommentTypePRUnScheduledToAutoMerge {
return nil , fmt . Errorf ( "comment type %d cannot be used to create an auto merge comment" , typ )
}
2022-11-19 16:12:33 +08:00
if err = pr . LoadIssue ( ctx ) ; err != nil {
2023-07-09 19:58:06 +08:00
return nil , err
2022-05-08 21:46:34 +08:00
}
2022-11-19 16:12:33 +08:00
if err = pr . LoadBaseRepo ( ctx ) ; err != nil {
2023-07-09 19:58:06 +08:00
return nil , err
2022-05-08 21:46:34 +08:00
}
2022-12-10 10:46:31 +08:00
comment , err = CreateComment ( ctx , & CreateCommentOptions {
2022-05-08 21:46:34 +08:00
Type : typ ,
Doer : doer ,
Repo : pr . BaseRepo ,
Issue : pr . Issue ,
} )
2022-06-20 18:02:49 +08:00
return comment , err
2022-05-08 21:46:34 +08:00
}
2022-02-02 02:20:28 +08:00
// RemapExternalUser ExternalUserRemappable interface
func ( c * Comment ) RemapExternalUser ( externalName string , externalID , userID int64 ) error {
c . OriginalAuthor = externalName
c . OriginalAuthorID = externalID
c . PosterID = userID
return nil
}
// GetUserID ExternalUserRemappable interface
func ( c * Comment ) GetUserID ( ) int64 { return c . PosterID }
// GetExternalName ExternalUserRemappable interface
func ( c * Comment ) GetExternalName ( ) string { return c . OriginalAuthor }
// GetExternalID ExternalUserRemappable interface
func ( c * Comment ) GetExternalID ( ) int64 { return c . OriginalAuthorID }
2022-06-13 17:37:59 +08:00
// CountCommentTypeLabelWithEmptyLabel count label comments with empty label
2022-11-19 16:12:33 +08:00
func CountCommentTypeLabelWithEmptyLabel ( ctx context . Context ) ( int64 , error ) {
return db . GetEngine ( ctx ) . Where ( builder . Eq { "type" : CommentTypeLabel , "label_id" : 0 } ) . Count ( new ( Comment ) )
2022-06-13 17:37:59 +08:00
}
// FixCommentTypeLabelWithEmptyLabel count label comments with empty label
2022-11-19 16:12:33 +08:00
func FixCommentTypeLabelWithEmptyLabel ( ctx context . Context ) ( int64 , error ) {
return db . GetEngine ( ctx ) . Where ( builder . Eq { "type" : CommentTypeLabel , "label_id" : 0 } ) . Delete ( new ( Comment ) )
2022-06-13 17:37:59 +08:00
}
// CountCommentTypeLabelWithOutsideLabels count label comments with outside label
2022-11-19 16:12:33 +08:00
func CountCommentTypeLabelWithOutsideLabels ( ctx context . Context ) ( int64 , error ) {
return db . GetEngine ( ctx ) . Where ( "comment.type = ? AND ((label.org_id = 0 AND issue.repo_id != label.repo_id) OR (label.repo_id = 0 AND label.org_id != repository.owner_id))" , CommentTypeLabel ) .
2022-06-13 17:37:59 +08:00
Table ( "comment" ) .
Join ( "inner" , "label" , "label.id = comment.label_id" ) .
Join ( "inner" , "issue" , "issue.id = comment.issue_id " ) .
Join ( "inner" , "repository" , "issue.repo_id = repository.id" ) .
Count ( )
}
// FixCommentTypeLabelWithOutsideLabels count label comments with outside label
2022-11-19 16:12:33 +08:00
func FixCommentTypeLabelWithOutsideLabels ( ctx context . Context ) ( int64 , error ) {
res , err := db . GetEngine ( ctx ) . Exec ( ` DELETE FROM comment WHERE comment . id IN (
2022-06-13 17:37:59 +08:00
SELECT il_too . id FROM (
SELECT com . id
FROM comment AS com
INNER JOIN label ON com . label_id = label . id
INNER JOIN issue on issue . id = com . issue_id
INNER JOIN repository ON issue . repo_id = repository . id
WHERE
com . type = ? AND ( ( label . org_id = 0 AND issue . repo_id != label . repo_id ) OR ( label . repo_id = 0 AND label . org_id != repository . owner_id ) )
) AS il_too ) ` , CommentTypeLabel )
if err != nil {
return 0 , err
}
return res . RowsAffected ( )
}
2023-02-16 01:29:13 +08:00
// HasOriginalAuthor returns if a comment was migrated and has an original author.
func ( c * Comment ) HasOriginalAuthor ( ) bool {
return c . OriginalAuthor != "" && c . OriginalAuthorID != 0
}
2023-09-09 05:09:23 +08:00
// InsertIssueComments inserts many comments of issues.
func InsertIssueComments ( comments [ ] * Comment ) error {
if len ( comments ) == 0 {
return nil
}
issueIDs := make ( container . Set [ int64 ] )
for _ , comment := range comments {
issueIDs . Add ( comment . IssueID )
}
ctx , committer , err := db . TxContext ( db . DefaultContext )
if err != nil {
return err
}
defer committer . Close ( )
for _ , comment := range comments {
if _ , err := db . GetEngine ( ctx ) . NoAutoTime ( ) . Insert ( comment ) ; err != nil {
return err
}
for _ , reaction := range comment . Reactions {
reaction . IssueID = comment . IssueID
reaction . CommentID = comment . ID
}
if len ( comment . Reactions ) > 0 {
if err := db . Insert ( ctx , comment . Reactions ) ; err != nil {
return err
}
}
}
for issueID := range issueIDs {
if _ , err := db . Exec ( ctx , "UPDATE issue set num_comments = (SELECT count(*) FROM comment WHERE issue_id = ? AND `type`=?) WHERE id = ?" ,
issueID , CommentTypeComment , issueID ) ; err != nil {
return err
}
}
return committer . Commit ( )
}