2019-09-20 05:45:38 +00:00
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
2022-11-27 18:20:29 +00:00
|
|
|
// SPDX-License-Identifier: MIT
|
2019-09-20 05:45:38 +00:00
|
|
|
|
2022-06-13 09:37:59 +00:00
|
|
|
package issues
|
2019-09-20 05:45:38 +00:00
|
|
|
|
|
|
|
import (
|
2021-11-19 13:39:57 +00:00
|
|
|
"context"
|
2019-11-18 13:13:07 +00:00
|
|
|
"fmt"
|
|
|
|
|
2021-09-19 11:49:59 +00:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2022-05-11 10:09:36 +00:00
|
|
|
access_model "code.gitea.io/gitea/models/perm/access"
|
2021-12-10 01:27:50 +00:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2021-11-24 09:49:20 +00:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2019-09-20 05:45:38 +00:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2019-10-13 22:29:10 +00:00
|
|
|
"code.gitea.io/gitea/modules/references"
|
2019-09-20 05:45:38 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type crossReference struct {
|
|
|
|
Issue *Issue
|
2019-10-13 22:29:10 +00:00
|
|
|
Action references.XRefAction
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// crossReferencesContext is context to pass along findCrossReference functions
|
|
|
|
type crossReferencesContext struct {
|
|
|
|
Type CommentType
|
2021-11-24 09:49:20 +00:00
|
|
|
Doer *user_model.User
|
2019-09-20 05:45:38 +00:00
|
|
|
OrigIssue *Issue
|
|
|
|
OrigComment *Comment
|
2019-11-18 23:43:03 +00:00
|
|
|
RemoveOld bool
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
2022-05-20 14:08:52 +00:00
|
|
|
func findOldCrossReferences(ctx context.Context, issueID, commentID int64) ([]*Comment, error) {
|
2019-09-20 05:45:38 +00:00
|
|
|
active := make([]*Comment, 0, 10)
|
2022-05-20 14:08:52 +00:00
|
|
|
return active, db.GetEngine(ctx).Where("`ref_action` IN (?, ?, ?)", references.XRefActionNone, references.XRefActionCloses, references.XRefActionReopens).
|
2019-11-18 13:13:07 +00:00
|
|
|
And("`ref_issue_id` = ?", issueID).
|
2019-11-18 23:43:03 +00:00
|
|
|
And("`ref_comment_id` = ?", commentID).
|
|
|
|
Find(&active)
|
|
|
|
}
|
|
|
|
|
2022-05-20 14:08:52 +00:00
|
|
|
func neuterCrossReferences(ctx context.Context, issueID, commentID int64) error {
|
|
|
|
active, err := findOldCrossReferences(ctx, issueID, commentID)
|
2019-11-18 23:43:03 +00:00
|
|
|
if err != nil {
|
2019-09-20 05:45:38 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
ids := make([]int64, len(active))
|
|
|
|
for i, c := range active {
|
|
|
|
ids[i] = c.ID
|
|
|
|
}
|
2022-05-20 14:08:52 +00:00
|
|
|
return neuterCrossReferencesIds(ctx, ids)
|
2019-11-18 23:43:03 +00:00
|
|
|
}
|
|
|
|
|
2022-05-20 14:08:52 +00:00
|
|
|
func neuterCrossReferencesIds(ctx context.Context, ids []int64) error {
|
|
|
|
_, err := db.GetEngine(ctx).In("id", ids).Cols("`ref_action`").Update(&Comment{RefAction: references.XRefActionNeutered})
|
2019-09-20 05:45:38 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-06-13 09:37:59 +00:00
|
|
|
// AddCrossReferences add cross repositories references.
|
|
|
|
func (issue *Issue) AddCrossReferences(stdCtx context.Context, doer *user_model.User, removeOld bool) error {
|
2019-09-20 05:45:38 +00:00
|
|
|
var commentType CommentType
|
|
|
|
if issue.IsPull {
|
|
|
|
commentType = CommentTypePullRef
|
|
|
|
} else {
|
|
|
|
commentType = CommentTypeIssueRef
|
|
|
|
}
|
|
|
|
ctx := &crossReferencesContext{
|
|
|
|
Type: commentType,
|
|
|
|
Doer: doer,
|
|
|
|
OrigIssue: issue,
|
2019-11-18 23:43:03 +00:00
|
|
|
RemoveOld: removeOld,
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
2021-11-19 13:39:57 +00:00
|
|
|
return issue.createCrossReferences(stdCtx, ctx, issue.Title, issue.Content)
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
2021-11-19 13:39:57 +00:00
|
|
|
func (issue *Issue) createCrossReferences(stdCtx context.Context, ctx *crossReferencesContext, plaincontent, mdcontent string) error {
|
2021-12-10 01:27:50 +00:00
|
|
|
xreflist, err := ctx.OrigIssue.getCrossReferences(stdCtx, ctx, plaincontent, mdcontent)
|
2019-09-20 05:45:38 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-11-18 23:43:03 +00:00
|
|
|
if ctx.RemoveOld {
|
|
|
|
var commentID int64
|
|
|
|
if ctx.OrigComment != nil {
|
|
|
|
commentID = ctx.OrigComment.ID
|
|
|
|
}
|
2022-05-20 14:08:52 +00:00
|
|
|
active, err := findOldCrossReferences(stdCtx, ctx.OrigIssue.ID, commentID)
|
2019-11-18 23:43:03 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
ids := make([]int64, 0, len(active))
|
|
|
|
for _, c := range active {
|
|
|
|
found := false
|
|
|
|
for i, x := range xreflist {
|
|
|
|
if x.Issue.ID == c.IssueID && x.Action == c.RefAction {
|
|
|
|
found = true
|
|
|
|
xreflist = append(xreflist[:i], xreflist[i+1:]...)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !found {
|
|
|
|
ids = append(ids, c.ID)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(ids) > 0 {
|
2022-05-20 14:08:52 +00:00
|
|
|
if err = neuterCrossReferencesIds(stdCtx, ids); err != nil {
|
2019-11-18 23:43:03 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-09-20 05:45:38 +00:00
|
|
|
for _, xref := range xreflist {
|
2019-11-15 18:18:09 +00:00
|
|
|
var refCommentID int64
|
|
|
|
if ctx.OrigComment != nil {
|
|
|
|
refCommentID = ctx.OrigComment.ID
|
|
|
|
}
|
[FEAT] allow setting the update date on issues and comments
This field adds the possibility to set the update date when modifying
an issue through the API.
A 'NoAutoDate' in-memory field is added in the Issue struct.
If the update_at field is set, NoAutoDate is set to true and the
Issue's UpdatedUnix field is filled.
That information is passed down to the functions that actually updates
the database, which have been modified to not auto update dates if
requested.
A guard is added to the 'EditIssue' API call, to checks that the
udpate_at date is between the issue's creation date and the current
date (to avoid 'malicious' changes). It also limits the new feature
to project's owners and admins.
(cherry picked from commit c524d33402c76bc4cccea2806f289e08a009baae)
Add a SetIssueUpdateDate() function in services/issue.go
That function is used by some API calls to set the NoAutoDate and
UpdatedUnix fields of an Issue if an updated_at date is provided.
(cherry picked from commit f061caa6555e0c9e922ee1e73dd2e4337360e9fe)
Add an updated_at field to the API calls related to Issue's Labels.
The update date is applied to the issue's comment created to inform
about the modification of the issue's labels.
(cherry picked from commit ea36cf80f58f0ab20c565a8f5d063b90fd741f97)
Add an updated_at field to the API call for issue's attachment creation
The update date is applied to the issue's comment created to inform
about the modification of the issue's content, and is set as the
asset creation date.
(cherry picked from commit 96150971ca31b97e97e84d5f5eb95a177cc44e2e)
Checking Issue changes, with and without providing an updated_at date
Those unit tests are added:
- TestAPIEditIssueWithAutoDate
- TestAPIEditIssueWithNoAutoDate
- TestAPIAddIssueLabelsWithAutoDate
- TestAPIAddIssueLabelsWithNoAutoDate
- TestAPICreateIssueAttachmentWithAutoDate
- TestAPICreateIssueAttachmentWithNoAutoDate
(cherry picked from commit 4926a5d7a28581003545256632213bf4136b193d)
Add an updated_at field to the API call for issue's comment creation
The update date is used as the comment creation date, and is applied to
the issue as the update creation date.
(cherry picked from commit 76c8faecdc6cba48ca4fe07d1a916d1f1a4b37b4)
Add an updated_at field to the API call for issue's comment edition
The update date is used as the comment update date, and is applied to
the issue as an update date.
(cherry picked from commit cf787ad7fdb8e6273fdc35d7b5cc164b400207e9)
Add an updated_at field to the API call for comment's attachment creation
The update date is applied to the comment, and is set as the asset
creation date.
(cherry picked from commit 1e4ff424d39db7a4256cd9abf9c58b8d3e1b5c14)
Checking Comment changes, with and without providing an updated_at date
Those unit tests are added:
- TestAPICreateCommentWithAutoDate
- TestAPICreateCommentWithNoAutoDate
- TestAPIEditCommentWithAutoDate
- TestAPIEditCommentWithNoAutoDate
- TestAPICreateCommentAttachmentWithAutoDate
- TestAPICreateCommentAttachmentWithNoAutoDate
(cherry picked from commit da932152f1deb3039a399516a51c8b6757059c91)
Pettier code to set the update time of comments
Now uses sess.AllCols().NoAutoToime().SetExpr("updated_unix", ...)
XORM is smart enough to compose one single SQL UPDATE which all
columns + updated_unix.
(cherry picked from commit 1f6a42808dd739c0c2e49e6b7ae2967f120f43c2)
Issue edition: Keep the max of the milestone and issue update dates.
When editing an issue via the API, an updated_at date can be provided.
If the EditIssue call changes the issue's milestone, the milestone's
update date is to be changed accordingly, but only with a greater
value.
This ensures that a milestone's update date is the max of all issue's
update dates.
(cherry picked from commit 8f22ea182e6b49e933dc6534040160dd739ff18a)
Rewrite the 'AutoDate' tests using subtests
Also add a test to check the permissions to set a date, and a test
to check update dates on milestones.
The tests related to 'AutoDate' are:
- TestAPIEditIssueAutoDate
- TestAPIAddIssueLabelsAutoDate
- TestAPIEditIssueMilestoneAutoDate
- TestAPICreateIssueAttachmentAutoDate
- TestAPICreateCommentAutoDate
- TestAPIEditCommentWithDate
- TestAPICreateCommentAttachmentAutoDate
(cherry picked from commit 961fd13c551b3e50040acb7c914a00ead92de63f)
(cherry picked from commit d52f4eea44692ee773010cb66a69a603663947d5)
(cherry picked from commit 3540ea2a43155ca8cf5ab1a4a246babfb829db16)
Conflicts:
services/issue/issue.go
https://codeberg.org/forgejo/forgejo/pulls/1415
(cherry picked from commit 56720ade008c09122d825959171aa5346d645987)
Conflicts:
routers/api/v1/repo/issue_label.go
https://codeberg.org/forgejo/forgejo/pulls/1462
(cherry picked from commit 47c78927d6c7e7a50298fa67efad1e73723a0981)
2023-05-30 16:42:58 +00:00
|
|
|
if ctx.OrigIssue.NoAutoTime {
|
|
|
|
xref.Issue.NoAutoTime = true
|
|
|
|
xref.Issue.UpdatedUnix = ctx.OrigIssue.UpdatedUnix
|
|
|
|
}
|
2021-03-14 18:52:12 +00:00
|
|
|
opts := &CreateCommentOptions{
|
2019-11-15 18:18:09 +00:00
|
|
|
Type: ctx.Type,
|
|
|
|
Doer: ctx.Doer,
|
|
|
|
Repo: xref.Issue.Repo,
|
|
|
|
Issue: xref.Issue,
|
|
|
|
RefRepoID: ctx.OrigIssue.RepoID,
|
|
|
|
RefIssueID: ctx.OrigIssue.ID,
|
|
|
|
RefCommentID: refCommentID,
|
|
|
|
RefAction: xref.Action,
|
2019-11-18 13:13:07 +00:00
|
|
|
RefIsPull: ctx.OrigIssue.IsPull,
|
2019-12-01 02:44:39 +00:00
|
|
|
}
|
2022-12-10 02:46:31 +00:00
|
|
|
_, err := CreateComment(stdCtx, opts)
|
2019-12-01 02:44:39 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-12-10 01:27:50 +00:00
|
|
|
func (issue *Issue) getCrossReferences(stdCtx context.Context, ctx *crossReferencesContext, plaincontent, mdcontent string) ([]*crossReference, error) {
|
2019-09-20 05:45:38 +00:00
|
|
|
xreflist := make([]*crossReference, 0, 5)
|
2019-10-13 22:29:10 +00:00
|
|
|
var (
|
2021-12-10 01:27:50 +00:00
|
|
|
refRepo *repo_model.Repository
|
2019-11-18 13:13:07 +00:00
|
|
|
refIssue *Issue
|
|
|
|
refAction references.XRefAction
|
|
|
|
err error
|
2019-10-13 22:29:10 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
allrefs := append(references.FindAllIssueReferences(plaincontent), references.FindAllIssueReferencesMarkdown(mdcontent)...)
|
|
|
|
for _, ref := range allrefs {
|
|
|
|
if ref.Owner == "" && ref.Name == "" {
|
|
|
|
// Issues in the same repository
|
2022-04-08 09:11:15 +00:00
|
|
|
if err := ctx.OrigIssue.LoadRepo(stdCtx); err != nil {
|
2019-09-20 05:45:38 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2019-10-13 22:29:10 +00:00
|
|
|
refRepo = ctx.OrigIssue.Repo
|
|
|
|
} else {
|
|
|
|
// Issues in other repositories
|
2022-12-03 02:48:26 +00:00
|
|
|
refRepo, err = repo_model.GetRepositoryByOwnerAndName(stdCtx, ref.Owner, ref.Name)
|
2019-09-20 05:45:38 +00:00
|
|
|
if err != nil {
|
2021-12-10 01:27:50 +00:00
|
|
|
if repo_model.IsErrRepoNotExist(err) {
|
2019-09-20 05:45:38 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-10-13 22:29:10 +00:00
|
|
|
}
|
2021-12-10 01:27:50 +00:00
|
|
|
if refIssue, refAction, err = ctx.OrigIssue.verifyReferencedIssue(stdCtx, ctx, refRepo, ref); err != nil {
|
2019-10-13 22:29:10 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if refIssue != nil {
|
|
|
|
xreflist = ctx.OrigIssue.updateCrossReferenceList(xreflist, &crossReference{
|
2019-11-18 13:13:07 +00:00
|
|
|
Issue: refIssue,
|
|
|
|
Action: refAction,
|
2019-10-13 22:29:10 +00:00
|
|
|
})
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return xreflist, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (issue *Issue) updateCrossReferenceList(list []*crossReference, xref *crossReference) []*crossReference {
|
|
|
|
if xref.Issue.ID == issue.ID {
|
|
|
|
return list
|
|
|
|
}
|
|
|
|
for i, r := range list {
|
|
|
|
if r.Issue.ID == xref.Issue.ID {
|
2019-10-13 22:29:10 +00:00
|
|
|
if xref.Action != references.XRefActionNone {
|
2019-09-20 05:45:38 +00:00
|
|
|
list[i].Action = xref.Action
|
|
|
|
}
|
|
|
|
return list
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return append(list, xref)
|
|
|
|
}
|
|
|
|
|
2019-11-18 13:13:07 +00:00
|
|
|
// verifyReferencedIssue will check if the referenced issue exists, and whether the doer has permission to do what
|
2021-12-10 01:27:50 +00:00
|
|
|
func (issue *Issue) verifyReferencedIssue(stdCtx context.Context, ctx *crossReferencesContext, repo *repo_model.Repository,
|
2022-02-23 20:16:07 +00:00
|
|
|
ref references.IssueReference,
|
|
|
|
) (*Issue, references.XRefAction, error) {
|
2019-11-18 13:13:07 +00:00
|
|
|
refIssue := &Issue{RepoID: repo.ID, Index: ref.Index}
|
|
|
|
refAction := ref.Action
|
2021-12-10 01:27:50 +00:00
|
|
|
e := db.GetEngine(stdCtx)
|
2019-11-18 13:13:07 +00:00
|
|
|
|
2019-09-20 05:45:38 +00:00
|
|
|
if has, _ := e.Get(refIssue); !has {
|
2019-11-18 13:13:07 +00:00
|
|
|
return nil, references.XRefActionNone, nil
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
2022-04-08 09:11:15 +00:00
|
|
|
if err := refIssue.LoadRepo(stdCtx); err != nil {
|
2019-11-18 13:13:07 +00:00
|
|
|
return nil, references.XRefActionNone, err
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
2019-11-18 13:13:07 +00:00
|
|
|
|
|
|
|
// Close/reopen actions can only be set from pull requests to issues
|
|
|
|
if refIssue.IsPull || !issue.IsPull {
|
|
|
|
refAction = references.XRefActionNone
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check doer permissions; set action to None if the doer can't change the destination
|
|
|
|
if refIssue.RepoID != ctx.OrigIssue.RepoID || ref.Action != references.XRefActionNone {
|
2022-05-11 10:09:36 +00:00
|
|
|
perm, err := access_model.GetUserRepoPermission(stdCtx, refIssue.Repo, ctx.Doer)
|
2019-09-20 05:45:38 +00:00
|
|
|
if err != nil {
|
2019-11-18 13:13:07 +00:00
|
|
|
return nil, references.XRefActionNone, err
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
if !perm.CanReadIssuesOrPulls(refIssue.IsPull) {
|
2019-11-18 13:13:07 +00:00
|
|
|
return nil, references.XRefActionNone, nil
|
|
|
|
}
|
2019-11-18 17:03:49 +00:00
|
|
|
// Accept close/reopening actions only if the poster is able to close the
|
|
|
|
// referenced issue manually at this moment. The only exception is
|
|
|
|
// the poster of a new PR referencing an issue on the same repo: then the merger
|
|
|
|
// should be responsible for checking whether the reference should resolve.
|
2019-11-18 13:13:07 +00:00
|
|
|
if ref.Action != references.XRefActionNone &&
|
|
|
|
ctx.Doer.ID != refIssue.PosterID &&
|
2019-11-18 17:03:49 +00:00
|
|
|
!perm.CanWriteIssuesOrPulls(refIssue.IsPull) &&
|
|
|
|
(refIssue.RepoID != ctx.OrigIssue.RepoID || ctx.OrigComment != nil) {
|
2019-11-18 13:13:07 +00:00
|
|
|
refAction = references.XRefActionNone
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
}
|
2019-11-18 13:13:07 +00:00
|
|
|
|
|
|
|
return refIssue, refAction, nil
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
2022-06-13 09:37:59 +00:00
|
|
|
// AddCrossReferences add cross references
|
2022-06-20 10:02:49 +00:00
|
|
|
func (c *Comment) AddCrossReferences(stdCtx context.Context, doer *user_model.User, removeOld bool) error {
|
|
|
|
if c.Type != CommentTypeCode && c.Type != CommentTypeComment {
|
2019-09-20 05:45:38 +00:00
|
|
|
return nil
|
|
|
|
}
|
2022-11-19 08:12:33 +00:00
|
|
|
if err := c.LoadIssue(stdCtx); err != nil {
|
2019-09-20 05:45:38 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
ctx := &crossReferencesContext{
|
|
|
|
Type: CommentTypeCommentRef,
|
|
|
|
Doer: doer,
|
2022-06-20 10:02:49 +00:00
|
|
|
OrigIssue: c.Issue,
|
|
|
|
OrigComment: c,
|
2019-11-18 23:43:03 +00:00
|
|
|
RemoveOld: removeOld,
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
2022-06-20 10:02:49 +00:00
|
|
|
return c.Issue.createCrossReferences(stdCtx, ctx, "", c.Content)
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
2022-06-20 10:02:49 +00:00
|
|
|
func (c *Comment) neuterCrossReferences(ctx context.Context) error {
|
|
|
|
return neuterCrossReferences(ctx, c.IssueID, c.ID)
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// LoadRefComment loads comment that created this reference from database
|
2022-06-20 10:02:49 +00:00
|
|
|
func (c *Comment) LoadRefComment() (err error) {
|
|
|
|
if c.RefComment != nil {
|
2019-09-20 05:45:38 +00:00
|
|
|
return nil
|
|
|
|
}
|
2022-06-20 10:02:49 +00:00
|
|
|
c.RefComment, err = GetCommentByID(db.DefaultContext, c.RefCommentID)
|
|
|
|
return err
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// LoadRefIssue loads comment that created this reference from database
|
2022-06-20 10:02:49 +00:00
|
|
|
func (c *Comment) LoadRefIssue() (err error) {
|
|
|
|
if c.RefIssue != nil {
|
2019-09-20 05:45:38 +00:00
|
|
|
return nil
|
|
|
|
}
|
2022-06-20 10:02:49 +00:00
|
|
|
c.RefIssue, err = GetIssueByID(db.DefaultContext, c.RefIssueID)
|
2019-09-20 05:45:38 +00:00
|
|
|
if err == nil {
|
2022-06-20 10:02:49 +00:00
|
|
|
err = c.RefIssue.LoadRepo(db.DefaultContext)
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
2022-06-20 10:02:49 +00:00
|
|
|
return err
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CommentTypeIsRef returns true if CommentType is a reference from another issue
|
|
|
|
func CommentTypeIsRef(t CommentType) bool {
|
|
|
|
return t == CommentTypeCommentRef || t == CommentTypePullRef || t == CommentTypeIssueRef
|
|
|
|
}
|
|
|
|
|
2023-02-09 16:31:30 +00:00
|
|
|
// RefCommentLink returns the relative URL for the comment that created this reference
|
|
|
|
func (c *Comment) RefCommentLink() string {
|
2022-05-18 21:36:49 +00:00
|
|
|
// Edge case for when the reference is inside the title or the description of the referring issue
|
2022-06-20 10:02:49 +00:00
|
|
|
if c.RefCommentID == 0 {
|
2023-02-09 16:31:30 +00:00
|
|
|
return c.RefIssueLink()
|
2021-05-11 20:43:35 +00:00
|
|
|
}
|
2022-06-20 10:02:49 +00:00
|
|
|
if err := c.LoadRefComment(); err != nil { // Silently dropping errors :unamused:
|
|
|
|
log.Error("LoadRefComment(%d): %v", c.RefCommentID, err)
|
2019-09-20 05:45:38 +00:00
|
|
|
return ""
|
|
|
|
}
|
2023-02-09 16:31:30 +00:00
|
|
|
return c.RefComment.Link()
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
2023-02-09 16:31:30 +00:00
|
|
|
// RefIssueLink returns the relative URL of the issue where this reference was created
|
|
|
|
func (c *Comment) RefIssueLink() string {
|
2022-06-20 10:02:49 +00:00
|
|
|
if err := c.LoadRefIssue(); err != nil { // Silently dropping errors :unamused:
|
|
|
|
log.Error("LoadRefIssue(%d): %v", c.RefCommentID, err)
|
2019-09-20 05:45:38 +00:00
|
|
|
return ""
|
|
|
|
}
|
2023-02-09 16:31:30 +00:00
|
|
|
return c.RefIssue.Link()
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// RefIssueTitle returns the title of the issue where this reference was created
|
2022-06-20 10:02:49 +00:00
|
|
|
func (c *Comment) RefIssueTitle() string {
|
|
|
|
if err := c.LoadRefIssue(); err != nil { // Silently dropping errors :unamused:
|
|
|
|
log.Error("LoadRefIssue(%d): %v", c.RefCommentID, err)
|
2019-09-20 05:45:38 +00:00
|
|
|
return ""
|
|
|
|
}
|
2022-06-20 10:02:49 +00:00
|
|
|
return c.RefIssue.Title
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// RefIssueIdent returns the user friendly identity (e.g. "#1234") of the issue where this reference was created
|
2022-06-20 10:02:49 +00:00
|
|
|
func (c *Comment) RefIssueIdent() string {
|
|
|
|
if err := c.LoadRefIssue(); err != nil { // Silently dropping errors :unamused:
|
|
|
|
log.Error("LoadRefIssue(%d): %v", c.RefCommentID, err)
|
2019-09-20 05:45:38 +00:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
// FIXME: check this name for cross-repository references (#7901 if it gets merged)
|
2022-06-20 10:02:49 +00:00
|
|
|
return fmt.Sprintf("#%d", c.RefIssue.Index)
|
2019-09-20 05:45:38 +00:00
|
|
|
}
|
2019-11-18 13:13:07 +00:00
|
|
|
|
|
|
|
// __________ .__ .__ __________ __
|
|
|
|
// \______ \__ __| | | |\______ \ ____ ________ __ ____ _______/ |_
|
|
|
|
// | ___/ | \ | | | | _// __ \/ ____/ | \_/ __ \ / ___/\ __\
|
|
|
|
// | | | | / |_| |_| | \ ___< <_| | | /\ ___/ \___ \ | |
|
|
|
|
// |____| |____/|____/____/____|_ /\___ >__ |____/ \___ >____ > |__|
|
|
|
|
// \/ \/ |__| \/ \/
|
|
|
|
|
|
|
|
// ResolveCrossReferences will return the list of references to close/reopen by this PR
|
2022-05-03 19:46:28 +00:00
|
|
|
func (pr *PullRequest) ResolveCrossReferences(ctx context.Context) ([]*Comment, error) {
|
2019-11-18 13:13:07 +00:00
|
|
|
unfiltered := make([]*Comment, 0, 5)
|
2022-05-03 19:46:28 +00:00
|
|
|
if err := db.GetEngine(ctx).
|
2019-11-18 13:13:07 +00:00
|
|
|
Where("ref_repo_id = ? AND ref_issue_id = ?", pr.Issue.RepoID, pr.Issue.ID).
|
|
|
|
In("ref_action", []references.XRefAction{references.XRefActionCloses, references.XRefActionReopens}).
|
|
|
|
OrderBy("id").
|
|
|
|
Find(&unfiltered); err != nil {
|
2022-10-24 19:29:17 +00:00
|
|
|
return nil, fmt.Errorf("get reference: %w", err)
|
2019-11-18 13:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
refs := make([]*Comment, 0, len(unfiltered))
|
|
|
|
for _, ref := range unfiltered {
|
|
|
|
found := false
|
|
|
|
for i, r := range refs {
|
|
|
|
if r.IssueID == ref.IssueID {
|
|
|
|
// Keep only the latest
|
|
|
|
refs[i] = ref
|
|
|
|
found = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !found {
|
|
|
|
refs = append(refs, ref)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return refs, nil
|
|
|
|
}
|