2018-08-06 10:13:22 +05:30
// Copyright 2018 The Gitea Authors.
// Copyright 2016 The Gogs Authors.
// All rights reserved.
2022-11-27 23:50:29 +05:30
// SPDX-License-Identifier: MIT
2016-03-05 23:28:51 +05:30
2022-06-13 15:07:59 +05:30
package issues
2016-03-05 23:28:51 +05:30
import (
2021-11-19 19:09:57 +05:30
"context"
2016-03-05 23:28:51 +05:30
"fmt"
2020-06-18 19:37:09 +05:30
"strconv"
"unicode/utf8"
2016-03-05 23:28:51 +05:30
2021-09-19 17:19:59 +05:30
"code.gitea.io/gitea/models/db"
2022-06-12 21:21:54 +05:30
git_model "code.gitea.io/gitea/models/git"
2022-03-29 11:59:02 +05:30
"code.gitea.io/gitea/models/organization"
2022-03-29 19:46:31 +05:30
project_model "code.gitea.io/gitea/models/project"
2021-11-19 19:09:57 +05:30
repo_model "code.gitea.io/gitea/models/repo"
2021-11-24 15:19:20 +05:30
user_model "code.gitea.io/gitea/models/user"
2023-09-09 02:39:23 +05:30
"code.gitea.io/gitea/modules/container"
2019-03-27 15:03:00 +05:30
"code.gitea.io/gitea/modules/git"
2021-07-24 21:33:58 +05:30
"code.gitea.io/gitea/modules/json"
2019-08-15 20:16:21 +05:30
"code.gitea.io/gitea/modules/log"
2019-10-14 03:59:10 +05:30
"code.gitea.io/gitea/modules/references"
2019-10-14 11:40:42 +05:30
"code.gitea.io/gitea/modules/structs"
2019-08-15 20:16:21 +05:30
"code.gitea.io/gitea/modules/timeutil"
2023-08-24 10:36:17 +05:30
"code.gitea.io/gitea/modules/translation"
2022-10-18 11:20:37 +05:30
"code.gitea.io/gitea/modules/util"
2019-08-15 20:16:21 +05:30
2019-06-23 20:52:43 +05:30
"xorm.io/builder"
2019-10-17 14:56:49 +05:30
"xorm.io/xorm"
2016-03-05 23:28:51 +05:30
)
2022-06-13 15:07:59 +05:30
// 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 11:20:37 +05:30
func ( err ErrCommentNotExist ) Unwrap ( ) error {
return util . ErrNotExist
}
2016-03-05 23:28:51 +05:30
// CommentType defines whether a comment is just a simple comment, an action (like close) or a reference.
type CommentType int
2023-04-20 12:09:44 +05:30
// CommentTypeUndefined is used to search for comments of any type
const CommentTypeUndefined CommentType = - 1
2017-06-21 06:30:44 +05:30
2016-03-05 23:28:51 +05:30
const (
2023-04-20 12:09:44 +05:30
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 18:47:19 +05:30
CommentTypePin // 36 pin Issue
CommentTypeUnpin // 37 unpin Issue
2016-03-05 23:28:51 +05:30
)
2022-01-01 19:42:25 +05:30
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-07 22:35:52 +05:30
"pull_scheduled_merge" ,
"pull_cancel_scheduled_merge" ,
2023-05-25 18:47:19 +05:30
"pin" ,
"unpin" ,
2022-01-01 19:42:25 +05:30
}
func ( t CommentType ) String ( ) string {
return commentStrings [ t ]
}
2023-01-19 07:44:56 +05:30
func AsCommentType ( typeName string ) CommentType {
for index , name := range commentStrings {
if typeName == name {
return CommentType ( index )
}
}
2023-04-20 12:09:44 +05:30
return CommentTypeUndefined
}
func ( t CommentType ) HasContentSupport ( ) bool {
switch t {
2023-06-23 16:03:20 +05:30
case CommentTypeComment , CommentTypeCode , CommentTypeReview , CommentTypeDismissReview :
2023-04-20 12:09:44 +05:30
return true
}
return false
}
func ( t CommentType ) HasAttachmentSupport ( ) bool {
switch t {
case CommentTypeComment , CommentTypeCode , CommentTypeReview :
return true
}
return false
2023-01-19 07:44:56 +05:30
}
2023-11-13 08:50:34 +05:30
func ( t CommentType ) HasMailReplySupport ( ) bool {
switch t {
case CommentTypeComment , CommentTypeCode , CommentTypeReview , CommentTypeDismissReview , CommentTypeReopen , CommentTypeClose , CommentTypeMergePull , CommentTypeAssignees :
return true
}
return false
}
2023-08-24 10:36:17 +05:30
// 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-05 23:28:51 +05:30
2021-11-11 11:59:30 +05:30
// Enumerate all the role tags.
2016-03-05 23:28:51 +05:30
const (
2023-08-24 10:36:17 +05:30
RoleRepoOwner RoleInRepo = "owner"
RoleRepoMember RoleInRepo = "member"
RoleRepoCollaborator RoleInRepo = "collaborator"
RoleRepoFirstTimeContributor RoleInRepo = "first_time_contributor"
RoleRepoContributor RoleInRepo = "contributor"
2016-03-05 23:28:51 +05:30
)
2023-08-24 10:36:17 +05:30
// 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 11:59:30 +05:30
}
2023-08-24 10:36:17 +05:30
// 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 11:59:30 +05:30
}
2016-03-05 23:28:51 +05:30
// Comment represents a comment in commit and issue page.
type Comment struct {
2021-11-24 15:19:20 +05:30
ID int64 ` xorm:"pk autoincr" `
Type CommentType ` xorm:"INDEX" `
PosterID int64 ` xorm:"INDEX" `
Poster * user_model . User ` xorm:"-" `
2019-07-08 07:44:12 +05:30
OriginalAuthor string
OriginalAuthorID int64
2018-07-18 02:53:58 +05:30
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
LabelID int64
2020-10-26 03:19:48 +05:30
Label * Label ` xorm:"-" `
AddedLabels [ ] * Label ` xorm:"-" `
RemovedLabels [ ] * Label ` xorm:"-" `
2020-08-17 08:37:38 +05:30
OldProjectID int64
ProjectID int64
2022-03-29 19:46:31 +05:30
OldProject * project_model . Project ` xorm:"-" `
Project * project_model . Project ` xorm:"-" `
2018-07-18 02:53:58 +05:30
OldMilestoneID int64
MilestoneID int64
2022-06-13 15:07:59 +05:30
OldMilestone * Milestone ` xorm:"-" `
Milestone * Milestone ` xorm:"-" `
2021-02-19 16:22:11 +05:30
TimeID int64
Time * TrackedTime ` xorm:"-" `
2018-07-18 02:53:58 +05:30
AssigneeID int64
RemovedAssignee bool
2022-03-29 11:59:02 +05:30
Assignee * user_model . User ` xorm:"-" `
AssigneeTeamID int64 ` xorm:"NOT NULL DEFAULT 0" `
AssigneeTeam * organization . Team ` xorm:"-" `
2020-04-18 19:20:25 +05:30
ResolveDoerID int64
2021-11-24 15:19:20 +05:30
ResolveDoer * user_model . User ` xorm:"-" `
2018-07-18 02:53:58 +05:30
OldTitle string
NewTitle string
2019-12-16 11:50:25 +05:30
OldRef string
NewRef string
2023-09-29 02:28:35 +05:30
DependentIssueID int64 ` xorm:"index" ` // This is used by issue_service.deleteIssue
2018-07-18 02:53:58 +05:30
DependentIssue * Issue ` xorm:"-" `
2017-02-03 20:39:10 +05:30
2017-02-01 08:06:08 +05:30
CommitID int64
2018-08-06 10:13:22 +05:30
Line int64 // - previous line / + proposed line
TreePath string
2021-08-22 21:03:05 +05:30
Content string ` xorm:"LONGTEXT" `
2016-03-10 06:23:30 +05:30
RenderedContent string ` xorm:"-" `
2018-08-06 10:13:22 +05:30
// Path represents the 4 lines of code cemented by this comment
2020-06-18 19:37:09 +05:30
Patch string ` xorm:"-" `
2021-08-22 21:03:05 +05:30
PatchQuoted string ` xorm:"LONGTEXT patch" `
2018-08-06 10:13:22 +05:30
2019-08-15 20:16:21 +05:30
CreatedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"INDEX updated" `
2016-03-05 23:28:51 +05:30
// Reference issue in commit message
CommitSHA string ` xorm:"VARCHAR(40)" `
2022-06-13 15:07:59 +05:30
Attachments [ ] * repo_model . Attachment ` xorm:"-" `
Reactions ReactionList ` xorm:"-" `
2016-03-05 23:28:51 +05:30
// For view issue page.
2021-11-11 11:59:30 +05:30
ShowRole RoleDescriptor ` xorm:"-" `
2018-08-06 10:13:22 +05:30
Review * Review ` xorm:"-" `
2019-08-05 19:59:40 +05:30
ReviewID int64 ` xorm:"index" `
2018-08-06 10:13:22 +05:30
Invalidated bool
2019-09-20 11:15:38 +05:30
// Reference an issue or pull from another comment, issue or PR
// All information is about the origin of the reference
2019-10-14 03:59:10 +05:30
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 17:08:13 +05:30
RefAction references . XRefAction ` xorm:"SMALLINT" ` // What happens if RefIssueID resolves
2019-09-20 11:15:38 +05:30
RefIsPull bool
2021-12-10 06:57:50 +05:30
RefRepo * repo_model . Repository ` xorm:"-" `
RefIssue * Issue ` xorm:"-" `
RefComment * Comment ` xorm:"-" `
2020-05-20 18:17:24 +05:30
2022-06-12 21:21:54 +05:30
Commits [ ] * git_model . SignCommitWithStatuses ` xorm:"-" `
OldCommit string ` xorm:"-" `
NewCommit string ` xorm:"-" `
CommitsNum int64 ` xorm:"-" `
IsForcePush bool ` xorm:"-" `
2020-05-20 18:17:24 +05:30
}
2021-09-19 17:19:59 +05:30
func init ( ) {
db . RegisterModel ( new ( Comment ) )
}
2020-05-20 18:17:24 +05:30
// PushActionContent is content of push pull comment
type PushActionContent struct {
IsForcePush bool ` json:"is_force_push" `
CommitIDs [ ] string ` json:"commit_ids" `
2016-03-05 23:28:51 +05:30
}
2022-11-19 13:42:33 +05:30
// LoadIssue loads the issue reference for the comment
func ( c * Comment ) LoadIssue ( ctx context . Context ) ( err error ) {
2018-05-16 19:31:55 +05:30
if c . Issue != nil {
return nil
}
2022-06-13 15:07:59 +05:30
c . Issue , err = GetIssueByID ( ctx , c . IssueID )
2022-06-20 15:32:49 +05:30
return err
2018-05-16 19:31:55 +05:30
}
2020-06-18 19:37:09 +05:30
// 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 13:42:33 +05:30
// LoadPoster loads comment poster
func ( c * Comment ) LoadPoster ( ctx context . Context ) ( err error ) {
2023-11-13 20:00:08 +05:30
if c . Poster != nil {
2019-04-18 10:30:03 +05:30
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 07:15:19 +05:30
c . Poster , err = user_model . GetPossibleUserByID ( ctx , c . PosterID )
2019-04-18 10:30:03 +05:30
if err != nil {
2021-11-24 15:19:20 +05:30
if user_model . IsErrUserNotExist ( err ) {
2023-10-20 20:13:08 +05:30
c . PosterID = user_model . GhostUserID
2021-11-24 15:19:20 +05:30
c . Poster = user_model . NewGhostUser ( )
2019-04-18 10:30:03 +05:30
} else {
log . Error ( "getUserByID[%d]: %v" , c . ID , err )
}
}
return err
}
2016-11-28 19:03:09 +05:30
// AfterDelete is invoked from XORM after the object is deleted.
2023-09-15 11:43:19 +05:30
func ( c * Comment ) AfterDelete ( ctx context . Context ) {
2018-06-12 04:24:30 +05:30
if c . ID <= 0 {
return
}
2023-09-15 11:43:19 +05:30
_ , err := repo_model . DeleteAttachmentsByComment ( ctx , c . ID , true )
2016-03-05 23:28:51 +05:30
if err != nil {
log . Info ( "Could not delete files for comment %d on issue #%d: %s" , c . ID , c . IssueID , err )
}
}
2016-12-22 13:59:26 +05:30
// HTMLURL formats a URL-string to the issue-comment
2023-09-29 17:42:54 +05:30
func ( c * Comment ) HTMLURL ( ctx context . Context ) string {
err := c . LoadIssue ( ctx )
2016-12-22 13:59:26 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2016-12-22 13:59:26 +05:30
return ""
}
2023-09-29 17:42:54 +05:30
err = c . Issue . LoadRepo ( ctx )
2018-12-13 21:25:43 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 21:25:43 +05:30
return ""
}
2023-09-29 17:42:54 +05:30
return c . Issue . HTMLURL ( ) + c . hashLink ( ctx )
2023-02-06 23:39:18 +05:30
}
// Link formats a relative URL-string to the issue-comment
2023-09-29 17:42:54 +05:30
func ( c * Comment ) Link ( ctx context . Context ) string {
err := c . LoadIssue ( ctx )
2023-02-06 23:39:18 +05:30
if err != nil { // Silently dropping errors :unamused:
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
return ""
}
2023-09-29 17:42:54 +05:30
err = c . Issue . LoadRepo ( ctx )
2023-02-06 23:39:18 +05:30
if err != nil { // Silently dropping errors :unamused:
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
return ""
}
2023-09-29 17:42:54 +05:30
return c . Issue . Link ( ) + c . hashLink ( ctx )
2023-02-06 23:39:18 +05:30
}
2023-09-29 17:42:54 +05:30
func ( c * Comment ) hashLink ( ctx context . Context ) string {
2018-08-06 10:13:22 +05:30
if c . Type == CommentTypeCode {
if c . ReviewID == 0 {
2023-02-06 23:39:18 +05:30
return "/files#" + c . HashTag ( )
2018-08-06 10:13:22 +05:30
}
if c . Review == nil {
2023-09-29 17:42:54 +05:30
if err := c . LoadReview ( ctx ) ; err != nil {
2018-08-06 10:13:22 +05:30
log . Warn ( "LoadReview(%d): %v" , c . ReviewID , err )
2023-02-06 23:39:18 +05:30
return "/files#" + c . HashTag ( )
2018-08-06 10:13:22 +05:30
}
}
if c . Review . Type <= ReviewTypePending {
2023-02-06 23:39:18 +05:30
return "/files#" + c . HashTag ( )
2018-08-06 10:13:22 +05:30
}
}
2023-02-06 23:39:18 +05:30
return "#" + c . HashTag ( )
2016-12-22 13:59:26 +05:30
}
2020-01-09 17:26:32 +05:30
// APIURL formats a API-string to the issue-comment
2023-09-29 17:42:54 +05:30
func ( c * Comment ) APIURL ( ctx context . Context ) string {
err := c . LoadIssue ( ctx )
2020-01-09 17:26:32 +05:30
if err != nil { // Silently dropping errors :unamused:
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
return ""
}
2023-09-29 17:42:54 +05:30
err = c . Issue . LoadRepo ( ctx )
2020-01-09 17:26:32 +05:30
if err != nil { // Silently dropping errors :unamused:
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
return ""
}
2020-01-14 21:07:19 +05:30
return fmt . Sprintf ( "%s/issues/comments/%d" , c . Issue . Repo . APIURL ( ) , c . ID )
2020-01-09 17:26:32 +05:30
}
2016-12-22 13:59:26 +05:30
// IssueURL formats a URL-string to the issue
2023-09-29 17:42:54 +05:30
func ( c * Comment ) IssueURL ( ctx context . Context ) string {
err := c . LoadIssue ( ctx )
2016-12-22 13:59:26 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2016-12-22 13:59:26 +05:30
return ""
}
2018-05-16 19:31:55 +05:30
if c . Issue . IsPull {
2016-12-22 13:59:26 +05:30
return ""
}
2018-12-13 21:25:43 +05:30
2023-09-29 17:42:54 +05:30
err = c . Issue . LoadRepo ( ctx )
2018-12-13 21:25:43 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 21:25:43 +05:30
return ""
}
2018-05-16 19:31:55 +05:30
return c . Issue . HTMLURL ( )
2016-12-22 13:59:26 +05:30
}
// PRURL formats a URL-string to the pull-request
2023-09-29 17:42:54 +05:30
func ( c * Comment ) PRURL ( ctx context . Context ) string {
err := c . LoadIssue ( ctx )
2016-12-22 13:59:26 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2016-12-22 13:59:26 +05:30
return ""
}
2023-09-29 17:42:54 +05:30
err = c . Issue . LoadRepo ( ctx )
2018-12-13 21:25:43 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 21:25:43 +05:30
return ""
}
2018-05-16 19:31:55 +05:30
if ! c . Issue . IsPull {
2016-12-22 13:59:26 +05:30
return ""
}
2018-05-16 19:31:55 +05:30
return c . Issue . HTMLURL ( )
2016-12-22 13:59:26 +05:30
}
2018-05-16 19:31:55 +05:30
// CommentHashTag returns unique hash tag for comment id.
func CommentHashTag ( id int64 ) string {
return fmt . Sprintf ( "issuecomment-%d" , id )
}
2016-03-05 23:28:51 +05:30
// HashTag returns unique hash tag for comment.
func ( c * Comment ) HashTag ( ) string {
2018-05-16 19:31:55 +05:30
return CommentHashTag ( c . ID )
2016-03-05 23:28:51 +05:30
}
// EventTag returns unique event hash tag for comment.
func ( c * Comment ) EventTag ( ) string {
2020-12-25 15:29:32 +05:30
return fmt . Sprintf ( "event-%d" , c . ID )
2016-03-05 23:28:51 +05:30
}
2017-01-30 18:16:45 +05:30
// LoadLabel if comment.Type is CommentTypeLabel, then load Label
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadLabel ( ctx context . Context ) error {
2017-01-30 18:16:45 +05:30
var label Label
2023-09-29 17:42:54 +05:30
has , err := db . GetEngine ( ctx ) . ID ( c . LabelID ) . Get ( & label )
2017-01-30 18:16:45 +05:30
if err != nil {
return err
2017-02-11 18:26:57 +05:30
} 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 18:16:45 +05:30
}
2017-02-11 18:26:57 +05:30
2017-01-30 18:16:45 +05:30
return nil
}
2020-08-17 08:37:38 +05:30
// LoadProject if comment.Type is CommentTypeProject, then load project.
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadProject ( ctx context . Context ) error {
2020-08-17 08:37:38 +05:30
if c . OldProjectID > 0 {
2022-03-29 19:46:31 +05:30
var oldProject project_model . Project
2023-09-29 17:42:54 +05:30
has , err := db . GetEngine ( ctx ) . ID ( c . OldProjectID ) . Get ( & oldProject )
2020-08-17 08:37:38 +05:30
if err != nil {
return err
} else if has {
c . OldProject = & oldProject
}
}
if c . ProjectID > 0 {
2022-03-29 19:46:31 +05:30
var project project_model . Project
2023-09-29 17:42:54 +05:30
has , err := db . GetEngine ( ctx ) . ID ( c . ProjectID ) . Get ( & project )
2020-08-17 08:37:38 +05:30
if err != nil {
return err
} else if has {
c . Project = & project
}
}
return nil
}
2017-02-01 08:06:08 +05:30
// LoadMilestone if comment.Type is CommentTypeMilestone, then load milestone
2022-11-19 13:42:33 +05:30
func ( c * Comment ) LoadMilestone ( ctx context . Context ) error {
2017-02-01 08:06:08 +05:30
if c . OldMilestoneID > 0 {
2022-06-13 15:07:59 +05:30
var oldMilestone Milestone
2022-11-19 13:42:33 +05:30
has , err := db . GetEngine ( ctx ) . ID ( c . OldMilestoneID ) . Get ( & oldMilestone )
2017-02-01 08:06:08 +05:30
if err != nil {
return err
2017-06-17 10:21:28 +05:30
} else if has {
c . OldMilestone = & oldMilestone
2017-02-01 08:06:08 +05:30
}
}
if c . MilestoneID > 0 {
2022-06-13 15:07:59 +05:30
var milestone Milestone
2022-11-19 13:42:33 +05:30
has , err := db . GetEngine ( ctx ) . ID ( c . MilestoneID ) . Get ( & milestone )
2017-02-01 08:06:08 +05:30
if err != nil {
return err
2017-06-17 10:21:28 +05:30
} else if has {
c . Milestone = & milestone
2017-02-01 08:06:08 +05:30
}
}
return nil
}
2022-01-18 22:58:38 +05:30
// LoadAttachments loads attachments (it never returns error, the error during `GetAttachmentsByCommentIDCtx` is ignored)
2022-11-19 13:42:33 +05:30
func ( c * Comment ) LoadAttachments ( ctx context . Context ) error {
2018-12-13 21:25:43 +05:30
if len ( c . Attachments ) > 0 {
return nil
}
var err error
2022-11-19 13:42:33 +05:30
c . Attachments , err = repo_model . GetAttachmentsByCommentID ( ctx , c . ID )
2018-12-13 21:25:43 +05:30
if err != nil {
2019-04-02 13:18:31 +05:30
log . Error ( "getAttachmentsByCommentID[%d]: %v" , c . ID , err )
2018-12-13 21:25:43 +05:30
}
return nil
}
2019-10-15 17:49:32 +05:30
// UpdateAttachments update attachments by UUIDs for the comment
2023-09-29 17:42:54 +05:30
func ( c * Comment ) UpdateAttachments ( ctx context . Context , uuids [ ] string ) error {
ctx , committer , err := db . TxContext ( ctx )
2021-11-19 19:09:57 +05:30
if err != nil {
2019-10-15 17:49:32 +05:30
return err
}
2021-11-19 19:09:57 +05:30
defer committer . Close ( )
attachments , err := repo_model . GetAttachmentsByUUIDs ( ctx , uuids )
2019-10-15 17:49:32 +05:30
if err != nil {
2022-10-25 00:59:17 +05:30
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %w" , uuids , err )
2019-10-15 17:49:32 +05:30
}
for i := 0 ; i < len ( attachments ) ; i ++ {
attachments [ i ] . IssueID = c . IssueID
attachments [ i ] . CommentID = c . ID
2022-05-20 19:38:52 +05:30
if err := repo_model . UpdateAttachment ( ctx , attachments [ i ] ) ; err != nil {
2022-10-25 00:59:17 +05:30
return fmt . Errorf ( "update attachment [id: %d]: %w" , attachments [ i ] . ID , err )
2019-10-15 17:49:32 +05:30
}
}
2021-11-19 19:09:57 +05:30
return committer . Commit ( )
2019-10-15 17:49:32 +05:30
}
2020-10-13 01:25:13 +05:30
// LoadAssigneeUserAndTeam if comment.Type is CommentTypeAssignees, then load assignees
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadAssigneeUserAndTeam ( ctx context . Context ) error {
2017-02-03 20:39:10 +05:30
var err error
2020-10-13 01:25:13 +05:30
if c . AssigneeID > 0 && c . Assignee == nil {
2023-09-29 17:42:54 +05:30
c . Assignee , err = user_model . GetUserByID ( ctx , c . AssigneeID )
2017-02-03 20:39:10 +05:30
if err != nil {
2021-11-24 15:19:20 +05:30
if ! user_model . IsErrUserNotExist ( err ) {
2018-01-07 14:43:10 +05:30
return err
}
2021-11-24 15:19:20 +05:30
c . Assignee = user_model . NewGhostUser ( )
2017-02-03 20:39:10 +05:30
}
2020-10-13 01:25:13 +05:30
} else if c . AssigneeTeamID > 0 && c . AssigneeTeam == nil {
2023-09-29 17:42:54 +05:30
if err = c . LoadIssue ( ctx ) ; err != nil {
2020-10-13 01:25:13 +05:30
return err
}
2023-09-29 17:42:54 +05:30
if err = c . Issue . LoadRepo ( ctx ) ; err != nil {
2020-10-13 01:25:13 +05:30
return err
}
2023-09-29 17:42:54 +05:30
if err = c . Issue . Repo . LoadOwner ( ctx ) ; err != nil {
2020-10-13 01:25:13 +05:30
return err
}
if c . Issue . Repo . Owner . IsOrganization ( ) {
2023-09-29 17:42:54 +05:30
c . AssigneeTeam , err = organization . GetTeamByID ( ctx , c . AssigneeTeamID )
2022-03-29 11:59:02 +05:30
if err != nil && ! organization . IsErrTeamNotExist ( err ) {
2020-10-13 01:25:13 +05:30
return err
}
}
2017-02-03 20:39:10 +05:30
}
return nil
}
2020-04-18 19:20:25 +05:30
// LoadResolveDoer if comment.Type is CommentTypeCode and ResolveDoerID not zero, then load resolveDoer
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadResolveDoer ( ctx context . Context ) ( err error ) {
2020-04-18 19:20:25 +05:30
if c . ResolveDoerID == 0 || c . Type != CommentTypeCode {
return nil
}
2023-09-29 17:42:54 +05:30
c . ResolveDoer , err = user_model . GetUserByID ( ctx , c . ResolveDoerID )
2020-04-18 19:20:25 +05:30
if err != nil {
2021-11-24 15:19:20 +05:30
if user_model . IsErrUserNotExist ( err ) {
c . ResolveDoer = user_model . NewGhostUser ( )
2020-04-18 19:20:25 +05:30
err = nil
}
}
2022-06-20 15:32:49 +05:30
return err
2020-04-18 19:20:25 +05:30
}
// IsResolved check if an code comment is resolved
func ( c * Comment ) IsResolved ( ) bool {
return c . ResolveDoerID != 0 && c . Type == CommentTypeCode
}
2018-07-18 02:53:58 +05:30
// LoadDepIssueDetails loads Dependent Issue Details
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadDepIssueDetails ( ctx context . Context ) ( err error ) {
2018-07-18 02:53:58 +05:30
if c . DependentIssueID <= 0 || c . DependentIssue != nil {
return nil
}
2023-09-29 17:42:54 +05:30
c . DependentIssue , err = GetIssueByID ( ctx , c . DependentIssueID )
2018-07-18 02:53:58 +05:30
return err
}
2021-02-19 16:22:11 +05:30
// LoadTime loads the associated time for a CommentTypeAddTimeManual
2023-10-03 16:00:41 +05:30
func ( c * Comment ) LoadTime ( ctx context . Context ) error {
2021-02-19 16:22:11 +05:30
if c . Time != nil || c . TimeID == 0 {
return nil
}
var err error
2023-10-03 16:00:41 +05:30
c . Time , err = GetTrackedTimeByID ( ctx , c . TimeID )
2021-02-19 16:22:11 +05:30
return err
}
2022-03-31 14:50:39 +05:30
func ( c * Comment ) loadReactions ( ctx context . Context , repo * repo_model . Repository ) ( err error ) {
2017-12-04 04:44:26 +05:30
if c . Reactions != nil {
return nil
}
2022-06-13 15:07:59 +05:30
c . Reactions , _ , err = FindReactions ( ctx , FindReactionsOptions {
2017-12-04 04:44:26 +05:30
IssueID : c . IssueID ,
CommentID : c . ID ,
} )
if err != nil {
return err
}
// Load reaction user data
2022-03-31 14:50:39 +05:30
if _ , err := c . Reactions . LoadUsers ( ctx , repo ) ; err != nil {
2017-12-04 04:44:26 +05:30
return err
}
return nil
}
// LoadReactions loads comment reactions
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadReactions ( ctx context . Context , repo * repo_model . Repository ) error {
return c . loadReactions ( ctx , repo )
2017-12-04 04:44:26 +05:30
}
2022-05-20 19:38:52 +05:30
func ( c * Comment ) loadReview ( ctx context . Context ) ( err error ) {
2018-12-13 21:25:43 +05:30
if c . Review == nil {
2022-05-20 19:38:52 +05:30
if c . Review , err = GetReviewByID ( ctx , c . ReviewID ) ; err != nil {
2018-12-13 21:25:43 +05:30
return err
}
2018-08-06 10:13:22 +05:30
}
2019-05-06 17:39:31 +05:30
c . Review . Issue = c . Issue
2018-08-06 10:13:22 +05:30
return nil
}
// LoadReview loads the associated review
2023-09-29 17:42:54 +05:30
func ( c * Comment ) LoadReview ( ctx context . Context ) error {
return c . loadReview ( ctx )
2018-08-06 10:13:22 +05:30
}
// 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-06 23:39:18 +05:30
// CodeCommentLink returns the url to a comment in code
2023-09-29 17:42:54 +05:30
func ( c * Comment ) CodeCommentLink ( ctx context . Context ) string {
err := c . LoadIssue ( ctx )
2018-08-06 10:13:22 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "LoadIssue(%d): %v" , c . IssueID , err )
2018-08-06 10:13:22 +05:30
return ""
}
2023-09-29 17:42:54 +05:30
err = c . Issue . LoadRepo ( ctx )
2018-12-13 21:25:43 +05:30
if err != nil { // Silently dropping errors :unamused:
2019-04-02 13:18:31 +05:30
log . Error ( "loadRepo(%d): %v" , c . Issue . RepoID , err )
2018-12-13 21:25:43 +05:30
return ""
}
2023-02-06 23:39:18 +05:30
return fmt . Sprintf ( "%s/files#%s" , c . Issue . Link ( ) , c . HashTag ( ) )
2018-08-06 10:13:22 +05:30
}
2020-05-20 18:17:24 +05:30
// LoadPushCommits Load push commits
2022-01-20 04:56:57 +05:30
func ( c * Comment ) LoadPushCommits ( ctx context . Context ) ( err error ) {
2022-01-21 23:29:26 +05:30
if c . Content == "" || c . Commits != nil || c . Type != CommentTypePullRequestPush {
2020-05-20 18:17:24 +05:30
return nil
}
var data PushActionContent
err = json . Unmarshal ( [ ] byte ( c . Content ) , & data )
if err != nil {
2023-07-09 17:28:06 +05:30
return err
2020-05-20 18:17:24 +05:30
}
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 04:56:57 +05:30
gitRepo , closer , err := git . RepositoryFromContextOrOpen ( ctx , repoPath )
2020-05-20 18:17:24 +05:30
if err != nil {
return err
}
2022-01-20 04:56:57 +05:30
defer closer . Close ( )
2020-05-20 18:17:24 +05:30
2023-01-09 09:20:54 +05:30
c . Commits = git_model . ConvertFromGitCommit ( ctx , gitRepo . GetCommitsFromIDs ( data . CommitIDs ) , c . Issue . Repo )
2021-08-09 23:38:51 +05:30
c . CommitsNum = int64 ( len ( c . Commits ) )
2020-05-20 18:17:24 +05:30
}
return err
}
2022-12-10 08:16:31 +05:30
// CreateComment creates comment with context
func CreateComment ( ctx context . Context , opts * CreateCommentOptions ) ( _ * Comment , err error ) {
2023-08-04 19:04:34 +05:30
ctx , committer , err := db . TxContext ( ctx )
if err != nil {
return nil , err
}
defer committer . Close ( )
2021-11-19 19:09:57 +05:30
e := db . GetEngine ( ctx )
2017-01-30 18:16:45 +05:30
var LabelID int64
if opts . Label != nil {
LabelID = opts . Label . ID
}
2018-07-18 02:53:58 +05:30
2016-03-05 23:28:51 +05:30
comment := & Comment {
2018-07-18 02:53:58 +05:30
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 08:37:38 +05:30
OldProjectID : opts . OldProjectID ,
ProjectID : opts . ProjectID ,
2021-02-19 16:22:11 +05:30
TimeID : opts . TimeID ,
2018-07-18 02:53:58 +05:30
RemovedAssignee : opts . RemovedAssignee ,
AssigneeID : opts . AssigneeID ,
2020-10-13 01:25:13 +05:30
AssigneeTeamID : opts . AssigneeTeamID ,
2018-07-18 02:53:58 +05:30
CommitID : opts . CommitID ,
CommitSHA : opts . CommitSHA ,
Line : opts . LineNum ,
Content : opts . Content ,
OldTitle : opts . OldTitle ,
NewTitle : opts . NewTitle ,
2019-12-16 11:50:25 +05:30
OldRef : opts . OldRef ,
NewRef : opts . NewRef ,
2018-07-18 02:53:58 +05:30
DependentIssueID : opts . DependentIssueID ,
2018-08-06 10:13:22 +05:30
TreePath : opts . TreePath ,
ReviewID : opts . ReviewID ,
Patch : opts . Patch ,
2019-09-20 11:15:38 +05:30
RefRepoID : opts . RefRepoID ,
RefIssueID : opts . RefIssueID ,
RefCommentID : opts . RefCommentID ,
RefAction : opts . RefAction ,
RefIsPull : opts . RefIsPull ,
2020-05-20 18:17:24 +05:30
IsForcePush : opts . IsForcePush ,
2020-11-09 11:45:09 +05:30
Invalidated : opts . Invalidated ,
2016-03-05 23:28:51 +05:30
}
if _ , err = e . Insert ( comment ) ; err != nil {
return nil , err
}
2023-02-18 17:41:03 +05:30
if err = opts . Repo . LoadOwner ( ctx ) ; err != nil {
2017-01-30 18:16:45 +05:30
return nil , err
}
2021-11-19 19:09:57 +05:30
if err = updateCommentInfos ( ctx , opts , comment ) ; err != nil {
2019-11-06 19:09:29 +05:30
return nil , err
}
2022-06-13 15:07:59 +05:30
if err = comment . AddCrossReferences ( ctx , opts . Doer , false ) ; err != nil {
2019-09-20 11:15:38 +05:30
return nil , err
}
2023-08-04 19:04:34 +05:30
if err = committer . Commit ( ) ; err != nil {
return nil , err
}
2018-08-06 10:13:22 +05:30
return comment , nil
}
2021-11-19 19:09:57 +05:30
func updateCommentInfos ( ctx context . Context , opts * CreateCommentOptions , comment * Comment ) ( err error ) {
2016-03-05 23:28:51 +05:30
// Check comment type.
switch opts . Type {
2018-08-06 10:13:22 +05:30
case CommentTypeCode :
if comment . ReviewID != 0 {
if comment . Review == nil {
2022-05-20 19:38:52 +05:30
if err := comment . loadReview ( ctx ) ; err != nil {
2018-08-06 10:13:22 +05:30
return err
}
}
if comment . Review . Type <= ReviewTypePending {
return nil
}
}
fallthrough
2016-11-07 22:00:04 +05:30
case CommentTypeComment :
2022-05-20 19:38:52 +05:30
if _ , err = db . Exec ( ctx , "UPDATE `issue` SET num_comments=num_comments+1 WHERE id=?" , opts . Issue . ID ) ; err != nil {
2018-08-06 10:13:22 +05:30
return err
2016-03-05 23:28:51 +05:30
}
2022-01-13 22:20:43 +05:30
fallthrough
case CommentTypeReview :
2016-03-05 23:28:51 +05:30
// Check attachments
2021-11-19 19:09:57 +05:30
attachments , err := repo_model . GetAttachmentsByUUIDs ( ctx , opts . Attachments )
2019-12-11 05:31:52 +05:30
if err != nil {
2022-10-25 00:59:17 +05:30
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %w" , opts . Attachments , err )
2016-03-05 23:28:51 +05:30
}
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 19:38:52 +05:30
if _ , err = db . GetEngine ( ctx ) . ID ( attachments [ i ] . ID ) . Update ( attachments [ i ] ) ; err != nil {
2022-10-25 00:59:17 +05:30
return fmt . Errorf ( "update attachment [%d]: %w" , attachments [ i ] . ID , err )
2016-03-05 23:28:51 +05:30
}
}
2022-12-09 12:05:56 +05:30
comment . Attachments = attachments
2019-11-06 19:09:29 +05:30
case CommentTypeReopen , CommentTypeClose :
2022-10-25 18:17:46 +05:30
if err = repo_model . UpdateRepoIssueNumbers ( ctx , opts . Issue . RepoID , opts . Issue . IsPull , true ) ; err != nil {
2019-11-06 19:09:29 +05:30
return err
}
}
// update the issue's updated_unix column
2022-04-08 14:41:15 +05:30
return UpdateIssueCols ( ctx , opts . Issue , "updated_unix" )
2019-11-06 19:09:29 +05:30
}
2016-03-05 23:28:51 +05:30
2021-11-24 15:19:20 +05:30
func createDeadlineComment ( ctx context . Context , doer * user_model . User , issue * Issue , newDeadlineUnix timeutil . TimeStamp ) ( * Comment , error ) {
2018-05-02 00:35:28 +05:30
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 14:41:15 +05:30
if err := issue . LoadRepo ( ctx ) ; err != nil {
2018-12-27 20:32:43 +05:30
return nil , err
}
2021-03-15 00:22:12 +05:30
opts := & CreateCommentOptions {
2018-05-02 00:35:28 +05:30
Type : commentType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
Content : content ,
2019-12-01 08:14:39 +05:30
}
2022-12-10 08:16:31 +05:30
comment , err := CreateComment ( ctx , opts )
2019-12-01 08:14:39 +05:30
if err != nil {
return nil , err
}
2019-12-02 20:13:39 +05:30
return comment , nil
2018-05-02 00:35:28 +05:30
}
2018-07-18 02:53:58 +05:30
// Creates issue dependency comment
2021-11-24 15:19:20 +05:30
func createIssueDependencyComment ( ctx context . Context , doer * user_model . User , issue , dependentIssue * Issue , add bool ) ( err error ) {
2018-07-18 02:53:58 +05:30
cType := CommentTypeAddDependency
if ! add {
cType = CommentTypeRemoveDependency
}
2022-04-08 14:41:15 +05:30
if err = issue . LoadRepo ( ctx ) ; err != nil {
2023-07-09 17:28:06 +05:30
return err
2019-01-27 17:01:40 +05:30
}
2018-07-18 02:53:58 +05:30
// Make two comments, one in each issue
2021-03-15 00:22:12 +05:30
opts := & CreateCommentOptions {
2018-07-18 02:53:58 +05:30
Type : cType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
DependentIssueID : dependentIssue . ID ,
2019-12-01 08:14:39 +05:30
}
2022-12-10 08:16:31 +05:30
if _ , err = CreateComment ( ctx , opts ) ; err != nil {
2023-07-09 17:28:06 +05:30
return err
2018-07-18 02:53:58 +05:30
}
2019-12-01 08:14:39 +05:30
opts = & CreateCommentOptions {
2018-07-18 02:53:58 +05:30
Type : cType ,
Doer : doer ,
Repo : issue . Repo ,
Issue : dependentIssue ,
DependentIssueID : issue . ID ,
2019-12-01 08:14:39 +05:30
}
2022-12-10 08:16:31 +05:30
_ , err = CreateComment ( ctx , opts )
2022-06-20 15:32:49 +05:30
return err
2018-07-18 02:53:58 +05:30
}
2016-11-28 19:03:09 +05:30
// CreateCommentOptions defines options for creating comment
2016-03-05 23:28:51 +05:30
type CreateCommentOptions struct {
Type CommentType
2021-11-24 15:19:20 +05:30
Doer * user_model . User
2021-12-10 06:57:50 +05:30
Repo * repo_model . Repository
2016-03-05 23:28:51 +05:30
Issue * Issue
2017-01-30 18:16:45 +05:30
Label * Label
2016-03-05 23:28:51 +05:30
2018-07-18 02:53:58 +05:30
DependentIssueID int64
OldMilestoneID int64
MilestoneID int64
2020-08-17 08:37:38 +05:30
OldProjectID int64
ProjectID int64
2021-02-19 16:22:11 +05:30
TimeID int64
2018-07-18 02:53:58 +05:30
AssigneeID int64
2020-10-13 01:25:13 +05:30
AssigneeTeamID int64
2018-07-18 02:53:58 +05:30
RemovedAssignee bool
OldTitle string
NewTitle string
2019-12-16 11:50:25 +05:30
OldRef string
NewRef string
2018-07-18 02:53:58 +05:30
CommitID int64
CommitSHA string
2018-08-06 10:13:22 +05:30
Patch string
2018-07-18 02:53:58 +05:30
LineNum int64
2018-08-06 10:13:22 +05:30
TreePath string
ReviewID int64
2018-07-18 02:53:58 +05:30
Content string
Attachments [ ] string // UUIDs of attachments
2019-09-20 11:15:38 +05:30
RefRepoID int64
RefIssueID int64
RefCommentID int64
2019-10-14 03:59:10 +05:30
RefAction references . XRefAction
2019-09-20 11:15:38 +05:30
RefIsPull bool
2020-05-20 18:17:24 +05:30
IsForcePush bool
2020-11-09 11:45:09 +05:30
Invalidated bool
2016-03-05 23:28:51 +05:30
}
// GetCommentByID returns the comment by given ID.
2022-05-20 19:38:52 +05:30
func GetCommentByID ( ctx context . Context , id int64 ) ( * Comment , error ) {
2016-03-05 23:28:51 +05:30
c := new ( Comment )
2022-05-20 19:38:52 +05:30
has , err := db . GetEngine ( ctx ) . ID ( id ) . Get ( c )
2016-03-05 23:28:51 +05:30
if err != nil {
return nil , err
} else if ! has {
2016-08-27 02:10:53 +05:30
return nil , ErrCommentNotExist { id , 0 }
2016-03-05 23:28:51 +05:30
}
return c , nil
}
2017-06-21 06:30:44 +05:30
// FindCommentsOptions describes the conditions to Find comments
type FindCommentsOptions struct {
2021-09-24 17:02:56 +05:30
db . ListOptions
2023-01-18 02:33:44 +05:30
RepoID int64
IssueID int64
ReviewID int64
Since int64
Before int64
Line int64
TreePath string
Type CommentType
IssueIDs [ ] int64
Invalidated util . OptionalBool
2023-11-25 22:51:21 +05:30
IsPull util . OptionalBool
2017-06-21 06:30:44 +05:30
}
2023-01-18 02:33:44 +05:30
// ToConds implements FindOptions interface
2023-11-24 09:19:41 +05:30
func ( opts FindCommentsOptions ) ToConds ( ) builder . Cond {
2021-03-15 00:22:12 +05:30
cond := builder . NewCond ( )
2017-06-21 06:30:44 +05:30
if opts . RepoID > 0 {
cond = cond . And ( builder . Eq { "issue.repo_id" : opts . RepoID } )
2016-08-27 02:10:53 +05:30
}
2017-06-21 06:30:44 +05:30
if opts . IssueID > 0 {
cond = cond . And ( builder . Eq { "comment.issue_id" : opts . IssueID } )
2023-01-18 02:33:44 +05:30
} else if len ( opts . IssueIDs ) > 0 {
cond = cond . And ( builder . In ( "comment.issue_id" , opts . IssueIDs ) )
2017-06-21 06:30:44 +05:30
}
2018-08-06 10:13:22 +05:30
if opts . ReviewID > 0 {
cond = cond . And ( builder . Eq { "comment.review_id" : opts . ReviewID } )
}
2017-06-21 06:30:44 +05:30
if opts . Since > 0 {
cond = cond . And ( builder . Gte { "comment.updated_unix" : opts . Since } )
}
2020-01-13 21:32:24 +05:30
if opts . Before > 0 {
cond = cond . And ( builder . Lte { "comment.updated_unix" : opts . Before } )
}
2023-04-20 12:09:44 +05:30
if opts . Type != CommentTypeUndefined {
2017-06-21 06:30:44 +05:30
cond = cond . And ( builder . Eq { "comment.type" : opts . Type } )
}
2021-01-09 03:19:55 +05:30
if opts . Line != 0 {
2020-11-09 11:45:09 +05:30
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 02:33:44 +05:30
if ! opts . Invalidated . IsNone ( ) {
cond = cond . And ( builder . Eq { "comment.invalidated" : opts . Invalidated . IsTrue ( ) } )
}
2023-11-25 22:51:21 +05:30
if opts . IsPull != util . OptionalBoolNone {
cond = cond . And ( builder . Eq { "issue.is_pull" : opts . IsPull . IsTrue ( ) } )
}
2017-06-21 06:30:44 +05:30
return cond
2016-08-27 02:10:53 +05:30
}
2022-05-20 19:38:52 +05:30
// FindComments returns all comments according options
2023-05-21 18:18:28 +05:30
func FindComments ( ctx context . Context , opts * FindCommentsOptions ) ( CommentList , error ) {
2016-12-22 13:59:26 +05:30
comments := make ( [ ] * Comment , 0 , 10 )
2023-01-18 02:33:44 +05:30
sess := db . GetEngine ( ctx ) . Where ( opts . ToConds ( ) )
2023-11-25 22:51:21 +05:30
if opts . RepoID > 0 || opts . IsPull != util . OptionalBoolNone {
2017-06-21 06:30:44 +05:30
sess . Join ( "INNER" , "issue" , "issue.id = comment.issue_id" )
2016-12-22 13:59:26 +05:30
}
2020-01-25 00:30:29 +05:30
if opts . Page != 0 {
2021-09-24 17:02:56 +05:30
sess = db . SetSessionPagination ( sess , opts )
2020-01-25 00:30:29 +05:30
}
2020-11-09 11:45:09 +05:30
// WARNING: If you change this order you will need to fix createCodeComment
2017-06-21 06:30:44 +05:30
return comments , sess .
Asc ( "comment.created_unix" ) .
2017-11-03 08:41:42 +05:30
Asc ( "comment.id" ) .
2017-06-21 06:30:44 +05:30
Find ( & comments )
2016-12-22 13:59:26 +05:30
}
2021-08-12 18:13:08 +05:30
// CountComments count all comments according options by ignoring pagination
2023-09-29 17:42:54 +05:30
func CountComments ( ctx context . Context , opts * FindCommentsOptions ) ( int64 , error ) {
sess := db . GetEngine ( ctx ) . Where ( opts . ToConds ( ) )
2021-08-12 18:13:08 +05:30
if opts . RepoID > 0 {
sess . Join ( "INNER" , "issue" , "issue.id = comment.issue_id" )
}
return sess . Count ( & Comment { } )
}
2023-01-18 02:33:44 +05:30
// 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-05 23:28:51 +05:30
// UpdateComment updates information of comment.
2023-09-29 17:42:54 +05:30
func UpdateComment ( ctx context . Context , c * Comment , doer * user_model . User ) error {
ctx , committer , err := db . TxContext ( ctx )
2021-11-19 19:09:57 +05:30
if err != nil {
2017-09-17 01:46:21 +05:30
return err
}
2021-11-19 19:09:57 +05:30
defer committer . Close ( )
sess := db . GetEngine ( ctx )
2018-05-16 19:31:55 +05:30
2019-09-20 11:15:38 +05:30
if _ , err := sess . ID ( c . ID ) . AllCols ( ) . Update ( c ) ; err != nil {
2018-12-13 21:25:43 +05:30
return err
}
2022-11-19 13:42:33 +05:30
if err := c . LoadIssue ( ctx ) ; err != nil {
2018-05-16 19:31:55 +05:30
return err
}
2022-06-13 15:07:59 +05:30
if err := c . AddCrossReferences ( ctx , doer , true ) ; err != nil {
2019-09-20 11:15:38 +05:30
return err
}
2021-11-19 19:09:57 +05:30
if err := committer . Commit ( ) ; err != nil {
2022-10-25 00:59:17 +05:30
return fmt . Errorf ( "Commit: %w" , err )
2019-09-20 11:15:38 +05:30
}
2018-05-16 19:31:55 +05:30
2017-09-17 01:46:21 +05:30
return nil
2016-03-05 23:28:51 +05:30
}
2016-07-26 00:18:17 +05:30
2017-01-25 08:13:02 +05:30
// DeleteComment deletes the comment
2022-06-13 15:07:59 +05:30
func DeleteComment ( ctx context . Context , comment * Comment ) error {
2022-03-31 14:50:39 +05:30
e := db . GetEngine ( ctx )
2022-03-01 05:50:15 +05:30
if _ , err := e . ID ( comment . ID ) . NoAutoCondition ( ) . Delete ( comment ) ; err != nil {
2016-07-26 00:18:17 +05:30
return err
}
2022-06-13 15:07:59 +05:30
if _ , err := db . DeleteByBean ( ctx , & ContentHistory {
2021-10-11 04:10:03 +05:30
CommentID : comment . ID ,
} ) ; err != nil {
return err
}
2016-11-07 22:00:04 +05:30
if comment . Type == CommentTypeComment {
2022-03-18 03:34:09 +05:30
if _ , err := e . ID ( comment . IssueID ) . Decr ( "num_comments" ) . Update ( new ( Issue ) ) ; err != nil {
2016-07-26 00:18:17 +05:30
return err
}
}
2022-06-13 15:07:59 +05:30
if _ , err := e . Table ( "action" ) .
Where ( "comment_id = ?" , comment . ID ) .
2023-07-05 00:06:08 +05:30
Update ( map [ string ] any {
2022-06-13 15:07:59 +05:30
"is_deleted" : true ,
} ) ; err != nil {
2017-07-04 07:00:41 +05:30
return err
}
2016-07-26 00:18:17 +05:30
2022-05-20 19:38:52 +05:30
if err := comment . neuterCrossReferences ( ctx ) ; err != nil {
2019-09-20 11:15:38 +05:30
return err
}
2022-06-13 15:07:59 +05:30
return DeleteReaction ( ctx , & ReactionOptions { CommentID : comment . ID } )
2016-07-26 00:18:17 +05:30
}
2018-08-06 10:13:22 +05:30
2019-10-14 11:40:42 +05:30
// UpdateCommentsMigrationsByType updates comments' migrations information via given git service type and original id and poster id
2023-09-29 17:42:54 +05:30
func UpdateCommentsMigrationsByType ( ctx context . Context , tp structs . GitServiceType , originalAuthorID string , posterID int64 ) error {
_ , err := db . GetEngine ( ctx ) . Table ( "comment" ) .
2023-12-22 03:55:57 +05:30
Join ( "INNER" , "issue" , "issue.id = comment.issue_id" ) .
Join ( "INNER" , "repository" , "issue.repo_id = repository.id" ) .
Where ( "repository.original_service_type = ?" , tp ) .
2019-10-14 11:40:42 +05:30
And ( "comment.original_author_id = ?" , originalAuthorID ) .
2023-07-05 00:06:08 +05:30
Update ( map [ string ] any {
2019-10-14 11:40:42 +05:30
"poster_id" : posterID ,
"original_author" : "" ,
"original_author_id" : 0 ,
} )
return err
}
2020-05-20 18:17:24 +05:30
2022-05-08 19:16:34 +05:30
// 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 13:42:33 +05:30
if err = pr . LoadIssue ( ctx ) ; err != nil {
2023-07-09 17:28:06 +05:30
return nil , err
2022-05-08 19:16:34 +05:30
}
2022-11-19 13:42:33 +05:30
if err = pr . LoadBaseRepo ( ctx ) ; err != nil {
2023-07-09 17:28:06 +05:30
return nil , err
2022-05-08 19:16:34 +05:30
}
2022-12-10 08:16:31 +05:30
comment , err = CreateComment ( ctx , & CreateCommentOptions {
2022-05-08 19:16:34 +05:30
Type : typ ,
Doer : doer ,
Repo : pr . BaseRepo ,
Issue : pr . Issue ,
} )
2022-06-20 15:32:49 +05:30
return comment , err
2022-05-08 19:16:34 +05:30
}
2022-02-01 23:50:28 +05:30
// 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 15:07:59 +05:30
// CountCommentTypeLabelWithEmptyLabel count label comments with empty label
2022-11-19 13:42:33 +05:30
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 15:07:59 +05:30
}
// FixCommentTypeLabelWithEmptyLabel count label comments with empty label
2022-11-19 13:42:33 +05:30
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 15:07:59 +05:30
}
// CountCommentTypeLabelWithOutsideLabels count label comments with outside label
2022-11-19 13:42:33 +05:30
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 15:07:59 +05:30
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 13:42:33 +05:30
func FixCommentTypeLabelWithOutsideLabels ( ctx context . Context ) ( int64 , error ) {
res , err := db . GetEngine ( ctx ) . Exec ( ` DELETE FROM comment WHERE comment . id IN (
2022-06-13 15:07:59 +05:30
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-15 22:59:13 +05:30
// 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 02:39:23 +05:30
// InsertIssueComments inserts many comments of issues.
2023-09-29 17:42:54 +05:30
func InsertIssueComments ( ctx context . Context , comments [ ] * Comment ) error {
2023-09-09 02:39:23 +05:30
if len ( comments ) == 0 {
return nil
}
issueIDs := make ( container . Set [ int64 ] )
for _ , comment := range comments {
issueIDs . Add ( comment . IssueID )
}
2023-09-29 17:42:54 +05:30
ctx , committer , err := db . TxContext ( ctx )
2023-09-09 02:39:23 +05:30
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 ( )
}