}
// GetActFullName gets the action's user full name.
-func (a *Action) GetActFullName() string {
- a.LoadActUser(db.DefaultContext)
+func (a *Action) GetActFullName(ctx context.Context) string {
+ a.LoadActUser(ctx)
return a.ActUser.FullName
}
// GetActUserName gets the action's user name.
-func (a *Action) GetActUserName() string {
- a.LoadActUser(db.DefaultContext)
+func (a *Action) GetActUserName(ctx context.Context) string {
+ a.LoadActUser(ctx)
return a.ActUser.Name
}
// ShortActUserName gets the action's user name trimmed to max 20
// chars.
-func (a *Action) ShortActUserName() string {
- return base.EllipsisString(a.GetActUserName(), 20)
+func (a *Action) ShortActUserName(ctx context.Context) string {
+ return base.EllipsisString(a.GetActUserName(ctx), 20)
}
// GetDisplayName gets the action's display name based on DEFAULT_SHOW_FULL_NAME, or falls back to the username if it is blank.
-func (a *Action) GetDisplayName() string {
+func (a *Action) GetDisplayName(ctx context.Context) string {
if setting.UI.DefaultShowFullName {
- trimmedFullName := strings.TrimSpace(a.GetActFullName())
+ trimmedFullName := strings.TrimSpace(a.GetActFullName(ctx))
if len(trimmedFullName) > 0 {
return trimmedFullName
}
}
- return a.ShortActUserName()
+ return a.ShortActUserName(ctx)
}
// GetDisplayNameTitle gets the action's display name used for the title (tooltip) based on DEFAULT_SHOW_FULL_NAME
-func (a *Action) GetDisplayNameTitle() string {
+func (a *Action) GetDisplayNameTitle(ctx context.Context) string {
if setting.UI.DefaultShowFullName {
- return a.ShortActUserName()
+ return a.ShortActUserName(ctx)
}
- return a.GetActFullName()
+ return a.GetActFullName(ctx)
}
// GetRepoUserName returns the name of the action repository owner.
-func (a *Action) GetRepoUserName() string {
- a.loadRepo(db.DefaultContext)
+func (a *Action) GetRepoUserName(ctx context.Context) string {
+ a.loadRepo(ctx)
return a.Repo.OwnerName
}
// ShortRepoUserName returns the name of the action repository owner
// trimmed to max 20 chars.
-func (a *Action) ShortRepoUserName() string {
- return base.EllipsisString(a.GetRepoUserName(), 20)
+func (a *Action) ShortRepoUserName(ctx context.Context) string {
+ return base.EllipsisString(a.GetRepoUserName(ctx), 20)
}
// GetRepoName returns the name of the action repository.
-func (a *Action) GetRepoName() string {
- a.loadRepo(db.DefaultContext)
+func (a *Action) GetRepoName(ctx context.Context) string {
+ a.loadRepo(ctx)
return a.Repo.Name
}
// ShortRepoName returns the name of the action repository
// trimmed to max 33 chars.
-func (a *Action) ShortRepoName() string {
- return base.EllipsisString(a.GetRepoName(), 33)
+func (a *Action) ShortRepoName(ctx context.Context) string {
+ return base.EllipsisString(a.GetRepoName(ctx), 33)
}
// GetRepoPath returns the virtual path to the action repository.
-func (a *Action) GetRepoPath() string {
- return path.Join(a.GetRepoUserName(), a.GetRepoName())
+func (a *Action) GetRepoPath(ctx context.Context) string {
+ return path.Join(a.GetRepoUserName(ctx), a.GetRepoName(ctx))
}
// ShortRepoPath returns the virtual path to the action repository
// trimmed to max 20 + 1 + 33 chars.
-func (a *Action) ShortRepoPath() string {
- return path.Join(a.ShortRepoUserName(), a.ShortRepoName())
+func (a *Action) ShortRepoPath(ctx context.Context) string {
+ return path.Join(a.ShortRepoUserName(ctx), a.ShortRepoName(ctx))
}
// GetRepoLink returns relative link to action repository.
-func (a *Action) GetRepoLink() string {
+func (a *Action) GetRepoLink(ctx context.Context) string {
// path.Join will skip empty strings
- return path.Join(setting.AppSubURL, "/", url.PathEscape(a.GetRepoUserName()), url.PathEscape(a.GetRepoName()))
+ return path.Join(setting.AppSubURL, "/", url.PathEscape(a.GetRepoUserName(ctx)), url.PathEscape(a.GetRepoName(ctx)))
}
// GetRepoAbsoluteLink returns the absolute link to action repository.
-func (a *Action) GetRepoAbsoluteLink() string {
- return setting.AppURL + url.PathEscape(a.GetRepoUserName()) + "/" + url.PathEscape(a.GetRepoName())
+func (a *Action) GetRepoAbsoluteLink(ctx context.Context) string {
+ return setting.AppURL + url.PathEscape(a.GetRepoUserName(ctx)) + "/" + url.PathEscape(a.GetRepoName(ctx))
}
// GetCommentHTMLURL returns link to action comment.
-func (a *Action) GetCommentHTMLURL() string {
- return a.getCommentHTMLURL(db.DefaultContext)
+func (a *Action) GetCommentHTMLURL(ctx context.Context) string {
+ return a.getCommentHTMLURL(ctx)
}
func (a *Action) loadComment(ctx context.Context) (err error) {
}
_ = a.loadComment(ctx)
if a.Comment != nil {
- return a.Comment.HTMLURL()
+ return a.Comment.HTMLURL(ctx)
}
if len(a.GetIssueInfos()) == 0 {
return "#"
}
// GetCommentLink returns link to action comment.
-func (a *Action) GetCommentLink() string {
- return a.getCommentLink(db.DefaultContext)
+func (a *Action) GetCommentLink(ctx context.Context) string {
+ return a.getCommentLink(ctx)
}
func (a *Action) getCommentLink(ctx context.Context) string {
}
_ = a.loadComment(ctx)
if a.Comment != nil {
- return a.Comment.Link()
+ return a.Comment.Link(ctx)
}
if len(a.GetIssueInfos()) == 0 {
return "#"
}
// GetRefLink returns the action's ref link.
-func (a *Action) GetRefLink() string {
- return git.RefURL(a.GetRepoLink(), a.RefName)
+func (a *Action) GetRefLink(ctx context.Context) string {
+ return git.RefURL(a.GetRepoLink(ctx), a.RefName)
}
// GetTag returns the action's repository tag.
return strings.SplitN(a.Content, "|", 3)
}
-// GetIssueTitle returns the title of first issue associated
-// with the action. This function will be invoked in template so keep db.DefaultContext here
-func (a *Action) GetIssueTitle() string {
+// GetIssueTitle returns the title of first issue associated with the action.
+func (a *Action) GetIssueTitle(ctx context.Context) string {
index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64)
- issue, err := issues_model.GetIssueByIndex(db.DefaultContext, a.RepoID, index)
+ issue, err := issues_model.GetIssueByIndex(ctx, a.RepoID, index)
if err != nil {
log.Error("GetIssueByIndex: %v", err)
return "500 when get issue"
return nil, 0, fmt.Errorf("need at least one of these filters: RequestedUser, RequestedTeam, RequestedRepo")
}
- cond, err := activityQueryCondition(opts)
+ cond, err := activityQueryCondition(ctx, opts)
if err != nil {
return nil, 0, err
}
doer != nil && (doer.IsAdmin || user.ID == doer.ID)
}
-func activityQueryCondition(opts GetFeedsOptions) (builder.Cond, error) {
+func activityQueryCondition(ctx context.Context, opts GetFeedsOptions) (builder.Cond, error) {
cond := builder.NewCond()
if opts.RequestedTeam != nil && opts.RequestedUser == nil {
- org, err := user_model.GetUserByID(db.DefaultContext, opts.RequestedTeam.OrgID)
+ org, err := user_model.GetUserByID(ctx, opts.RequestedTeam.OrgID)
if err != nil {
return nil, err
}
}
// DeleteOldActions deletes all old actions from database.
-func DeleteOldActions(olderThan time.Duration) (err error) {
+func DeleteOldActions(ctx context.Context, olderThan time.Duration) (err error) {
if olderThan <= 0 {
return nil
}
- _, err = db.GetEngine(db.DefaultContext).Where("created_unix < ?", time.Now().Add(-olderThan).Unix()).Delete(&Action{})
+ _, err = db.GetEngine(ctx).Where("created_unix < ?", time.Now().Add(-olderThan).Unix()).Delete(&Action{})
return err
}
}
// NotifyWatchersActions creates batch of actions for every watcher.
-func NotifyWatchersActions(acts []*Action) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func NotifyWatchersActions(ctx context.Context, acts []*Action) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
action := &activities_model.Action{RepoID: repo.ID}
- assert.Equal(t, path.Join(owner.Name, repo.Name), action.GetRepoPath())
+ assert.Equal(t, path.Join(owner.Name, repo.Name), action.GetRepoPath(db.DefaultContext))
}
func TestAction_GetRepoLink(t *testing.T) {
action := &activities_model.Action{RepoID: repo.ID, CommentID: comment.ID}
setting.AppSubURL = "/suburl"
expected := path.Join(setting.AppSubURL, owner.Name, repo.Name)
- assert.Equal(t, expected, action.GetRepoLink())
- assert.Equal(t, repo.HTMLURL(), action.GetRepoAbsoluteLink())
- assert.Equal(t, comment.HTMLURL(), action.GetCommentHTMLURL())
+ assert.Equal(t, expected, action.GetRepoLink(db.DefaultContext))
+ assert.Equal(t, repo.HTMLURL(), action.GetRepoAbsoluteLink(db.DefaultContext))
+ assert.Equal(t, comment.HTMLURL(db.DefaultContext), action.GetCommentHTMLURL(db.DefaultContext))
}
func TestGetFeeds(t *testing.T) {
// CreateOrUpdateIssueNotifications creates an issue notification
// for each watcher, or updates it if already exists
// receiverID > 0 just send to receiver, else send to all watcher
-func CreateOrUpdateIssueNotifications(issueID, commentID, notificationAuthorID, receiverID int64) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func CreateOrUpdateIssueNotifications(ctx context.Context, issueID, commentID, notificationAuthorID, receiverID int64) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// GetRepo returns the repo of the notification
-func (n *Notification) GetRepo() (*repo_model.Repository, error) {
- return n.Repository, n.loadRepo(db.DefaultContext)
+func (n *Notification) GetRepo(ctx context.Context) (*repo_model.Repository, error) {
+ return n.Repository, n.loadRepo(ctx)
}
// GetIssue returns the issue of the notification
-func (n *Notification) GetIssue() (*issues_model.Issue, error) {
- return n.Issue, n.loadIssue(db.DefaultContext)
+func (n *Notification) GetIssue(ctx context.Context) (*issues_model.Issue, error) {
+ return n.Issue, n.loadIssue(ctx)
}
// HTMLURL formats a URL-string to the notification
-func (n *Notification) HTMLURL() string {
+func (n *Notification) HTMLURL(ctx context.Context) string {
switch n.Source {
case NotificationSourceIssue, NotificationSourcePullRequest:
if n.Comment != nil {
- return n.Comment.HTMLURL()
+ return n.Comment.HTMLURL(ctx)
}
return n.Issue.HTMLURL()
case NotificationSourceCommit:
}
// Link formats a relative URL-string to the notification
-func (n *Notification) Link() string {
+func (n *Notification) Link(ctx context.Context) string {
switch n.Source {
case NotificationSourceIssue, NotificationSourcePullRequest:
if n.Comment != nil {
- return n.Comment.Link()
+ return n.Comment.Link(ctx)
}
return n.Issue.Link()
case NotificationSourceCommit:
}
// GetUIDsAndNotificationCounts between the two provided times
-func GetUIDsAndNotificationCounts(since, until timeutil.TimeStamp) ([]UserIDCount, error) {
+func GetUIDsAndNotificationCounts(ctx context.Context, since, until timeutil.TimeStamp) ([]UserIDCount, error) {
sql := `SELECT user_id, count(*) AS count FROM notification ` +
`WHERE user_id IN (SELECT user_id FROM notification WHERE updated_unix >= ? AND ` +
`updated_unix < ?) AND status = ? GROUP BY user_id`
var res []UserIDCount
- return res, db.GetEngine(db.DefaultContext).SQL(sql, since, until, NotificationStatusUnread).Find(&res)
+ return res, db.GetEngine(ctx).SQL(sql, since, until, NotificationStatusUnread).Find(&res)
}
// SetIssueReadBy sets issue to be read by given user.
assert.NoError(t, unittest.PrepareTestDatabase())
issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
- assert.NoError(t, activities_model.CreateOrUpdateIssueNotifications(issue.ID, 0, 2, 0))
+ assert.NoError(t, activities_model.CreateOrUpdateIssueNotifications(db.DefaultContext, issue.ID, 0, 2, 0))
// User 9 is inactive, thus notifications for user 1 and 4 are created
notf := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{UserID: 1, IssueID: issue.ID})
func TestNotification_GetRepo(t *testing.T) {
assert.NoError(t, unittest.PrepareTestDatabase())
notf := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{RepoID: 1})
- repo, err := notf.GetRepo()
+ repo, err := notf.GetRepo(db.DefaultContext)
assert.NoError(t, err)
assert.Equal(t, repo, notf.Repository)
assert.EqualValues(t, notf.RepoID, repo.ID)
func TestNotification_GetIssue(t *testing.T) {
assert.NoError(t, unittest.PrepareTestDatabase())
notf := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{RepoID: 1})
- issue, err := notf.GetIssue()
+ issue, err := notf.GetIssue(db.DefaultContext)
assert.NoError(t, err)
assert.Equal(t, issue, notf.Issue)
assert.EqualValues(t, notf.IssueID, issue.ID)
groupByName = groupBy
}
- cond, err := activityQueryCondition(GetFeedsOptions{
+ cond, err := activityQueryCondition(ctx, GetFeedsOptions{
RequestedUser: user,
RequestedTeam: team,
Actor: doer,
user_model.ValidateCommitsWithEmails(ctx, commits),
repo.GetTrustModel(),
func(user *user_model.User) (bool, error) {
- return repo_model.IsOwnerMemberCollaborator(repo, user.ID)
+ return repo_model.IsOwnerMemberCollaborator(ctx, repo, user.ID)
},
),
repo,
}
// HTMLURL formats a URL-string to the issue-comment
-func (c *Comment) HTMLURL() string {
- err := c.LoadIssue(db.DefaultContext)
+func (c *Comment) HTMLURL(ctx context.Context) string {
+ err := c.LoadIssue(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("LoadIssue(%d): %v", c.IssueID, err)
return ""
}
- err = c.Issue.LoadRepo(db.DefaultContext)
+ err = c.Issue.LoadRepo(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("loadRepo(%d): %v", c.Issue.RepoID, err)
return ""
}
- return c.Issue.HTMLURL() + c.hashLink()
+ return c.Issue.HTMLURL() + c.hashLink(ctx)
}
// Link formats a relative URL-string to the issue-comment
-func (c *Comment) Link() string {
- err := c.LoadIssue(db.DefaultContext)
+func (c *Comment) Link(ctx context.Context) string {
+ err := c.LoadIssue(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("LoadIssue(%d): %v", c.IssueID, err)
return ""
}
- err = c.Issue.LoadRepo(db.DefaultContext)
+ err = c.Issue.LoadRepo(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("loadRepo(%d): %v", c.Issue.RepoID, err)
return ""
}
- return c.Issue.Link() + c.hashLink()
+ return c.Issue.Link() + c.hashLink(ctx)
}
-func (c *Comment) hashLink() string {
+func (c *Comment) hashLink(ctx context.Context) string {
if c.Type == CommentTypeCode {
if c.ReviewID == 0 {
return "/files#" + c.HashTag()
}
if c.Review == nil {
- if err := c.LoadReview(); err != nil {
+ if err := c.LoadReview(ctx); err != nil {
log.Warn("LoadReview(%d): %v", c.ReviewID, err)
return "/files#" + c.HashTag()
}
}
// APIURL formats a API-string to the issue-comment
-func (c *Comment) APIURL() string {
- err := c.LoadIssue(db.DefaultContext)
+func (c *Comment) APIURL(ctx context.Context) string {
+ err := c.LoadIssue(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("LoadIssue(%d): %v", c.IssueID, err)
return ""
}
- err = c.Issue.LoadRepo(db.DefaultContext)
+ err = c.Issue.LoadRepo(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("loadRepo(%d): %v", c.Issue.RepoID, err)
return ""
}
// IssueURL formats a URL-string to the issue
-func (c *Comment) IssueURL() string {
- err := c.LoadIssue(db.DefaultContext)
+func (c *Comment) IssueURL(ctx context.Context) string {
+ err := c.LoadIssue(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("LoadIssue(%d): %v", c.IssueID, err)
return ""
return ""
}
- err = c.Issue.LoadRepo(db.DefaultContext)
+ err = c.Issue.LoadRepo(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("loadRepo(%d): %v", c.Issue.RepoID, err)
return ""
}
// PRURL formats a URL-string to the pull-request
-func (c *Comment) PRURL() string {
- err := c.LoadIssue(db.DefaultContext)
+func (c *Comment) PRURL(ctx context.Context) string {
+ err := c.LoadIssue(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("LoadIssue(%d): %v", c.IssueID, err)
return ""
}
- err = c.Issue.LoadRepo(db.DefaultContext)
+ err = c.Issue.LoadRepo(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("loadRepo(%d): %v", c.Issue.RepoID, err)
return ""
}
// LoadLabel if comment.Type is CommentTypeLabel, then load Label
-func (c *Comment) LoadLabel() error {
+func (c *Comment) LoadLabel(ctx context.Context) error {
var label Label
- has, err := db.GetEngine(db.DefaultContext).ID(c.LabelID).Get(&label)
+ has, err := db.GetEngine(ctx).ID(c.LabelID).Get(&label)
if err != nil {
return err
} else if has {
}
// LoadProject if comment.Type is CommentTypeProject, then load project.
-func (c *Comment) LoadProject() error {
+func (c *Comment) LoadProject(ctx context.Context) error {
if c.OldProjectID > 0 {
var oldProject project_model.Project
- has, err := db.GetEngine(db.DefaultContext).ID(c.OldProjectID).Get(&oldProject)
+ has, err := db.GetEngine(ctx).ID(c.OldProjectID).Get(&oldProject)
if err != nil {
return err
} else if has {
if c.ProjectID > 0 {
var project project_model.Project
- has, err := db.GetEngine(db.DefaultContext).ID(c.ProjectID).Get(&project)
+ has, err := db.GetEngine(ctx).ID(c.ProjectID).Get(&project)
if err != nil {
return err
} else if has {
}
// UpdateAttachments update attachments by UUIDs for the comment
-func (c *Comment) UpdateAttachments(uuids []string) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func (c *Comment) UpdateAttachments(ctx context.Context, uuids []string) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// LoadAssigneeUserAndTeam if comment.Type is CommentTypeAssignees, then load assignees
-func (c *Comment) LoadAssigneeUserAndTeam() error {
+func (c *Comment) LoadAssigneeUserAndTeam(ctx context.Context) error {
var err error
if c.AssigneeID > 0 && c.Assignee == nil {
- c.Assignee, err = user_model.GetUserByID(db.DefaultContext, c.AssigneeID)
+ c.Assignee, err = user_model.GetUserByID(ctx, c.AssigneeID)
if err != nil {
if !user_model.IsErrUserNotExist(err) {
return err
c.Assignee = user_model.NewGhostUser()
}
} else if c.AssigneeTeamID > 0 && c.AssigneeTeam == nil {
- if err = c.LoadIssue(db.DefaultContext); err != nil {
+ if err = c.LoadIssue(ctx); err != nil {
return err
}
- if err = c.Issue.LoadRepo(db.DefaultContext); err != nil {
+ if err = c.Issue.LoadRepo(ctx); err != nil {
return err
}
- if err = c.Issue.Repo.LoadOwner(db.DefaultContext); err != nil {
+ if err = c.Issue.Repo.LoadOwner(ctx); err != nil {
return err
}
if c.Issue.Repo.Owner.IsOrganization() {
- c.AssigneeTeam, err = organization.GetTeamByID(db.DefaultContext, c.AssigneeTeamID)
+ c.AssigneeTeam, err = organization.GetTeamByID(ctx, c.AssigneeTeamID)
if err != nil && !organization.IsErrTeamNotExist(err) {
return err
}
}
// LoadResolveDoer if comment.Type is CommentTypeCode and ResolveDoerID not zero, then load resolveDoer
-func (c *Comment) LoadResolveDoer() (err error) {
+func (c *Comment) LoadResolveDoer(ctx context.Context) (err error) {
if c.ResolveDoerID == 0 || c.Type != CommentTypeCode {
return nil
}
- c.ResolveDoer, err = user_model.GetUserByID(db.DefaultContext, c.ResolveDoerID)
+ c.ResolveDoer, err = user_model.GetUserByID(ctx, c.ResolveDoerID)
if err != nil {
if user_model.IsErrUserNotExist(err) {
c.ResolveDoer = user_model.NewGhostUser()
}
// LoadDepIssueDetails loads Dependent Issue Details
-func (c *Comment) LoadDepIssueDetails() (err error) {
+func (c *Comment) LoadDepIssueDetails(ctx context.Context) (err error) {
if c.DependentIssueID <= 0 || c.DependentIssue != nil {
return nil
}
- c.DependentIssue, err = GetIssueByID(db.DefaultContext, c.DependentIssueID)
+ c.DependentIssue, err = GetIssueByID(ctx, c.DependentIssueID)
return err
}
}
// LoadReactions loads comment reactions
-func (c *Comment) LoadReactions(repo *repo_model.Repository) error {
- return c.loadReactions(db.DefaultContext, repo)
+func (c *Comment) LoadReactions(ctx context.Context, repo *repo_model.Repository) error {
+ return c.loadReactions(ctx, repo)
}
func (c *Comment) loadReview(ctx context.Context) (err error) {
}
// LoadReview loads the associated review
-func (c *Comment) LoadReview() error {
- return c.loadReview(db.DefaultContext)
+func (c *Comment) LoadReview(ctx context.Context) error {
+ return c.loadReview(ctx)
}
// DiffSide returns "previous" if Comment.Line is a LOC of the previous changes and "proposed" if it is a LOC of the proposed changes.
}
// CodeCommentLink returns the url to a comment in code
-func (c *Comment) CodeCommentLink() string {
- err := c.LoadIssue(db.DefaultContext)
+func (c *Comment) CodeCommentLink(ctx context.Context) string {
+ err := c.LoadIssue(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("LoadIssue(%d): %v", c.IssueID, err)
return ""
}
- err = c.Issue.LoadRepo(db.DefaultContext)
+ err = c.Issue.LoadRepo(ctx)
if err != nil { // Silently dropping errors :unamused:
log.Error("loadRepo(%d): %v", c.Issue.RepoID, err)
return ""
}
// CountComments count all comments according options by ignoring pagination
-func CountComments(opts *FindCommentsOptions) (int64, error) {
- sess := db.GetEngine(db.DefaultContext).Where(opts.ToConds())
+func CountComments(ctx context.Context, opts *FindCommentsOptions) (int64, error) {
+ sess := db.GetEngine(ctx).Where(opts.ToConds())
if opts.RepoID > 0 {
sess.Join("INNER", "issue", "issue.id = comment.issue_id")
}
}
// UpdateComment updates information of comment.
-func UpdateComment(c *Comment, doer *user_model.User) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func UpdateComment(ctx context.Context, c *Comment, doer *user_model.User) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// UpdateCommentsMigrationsByType updates comments' migrations information via given git service type and original id and poster id
-func UpdateCommentsMigrationsByType(tp structs.GitServiceType, originalAuthorID string, posterID int64) error {
- _, err := db.GetEngine(db.DefaultContext).Table("comment").
+func UpdateCommentsMigrationsByType(ctx context.Context, tp structs.GitServiceType, originalAuthorID string, posterID int64) error {
+ _, err := db.GetEngine(ctx).Table("comment").
Where(builder.In("issue_id",
builder.Select("issue.id").
From("issue").
}
// InsertIssueComments inserts many comments of issues.
-func InsertIssueComments(comments []*Comment) error {
+func InsertIssueComments(ctx context.Context, comments []*Comment) error {
if len(comments) == 0 {
return nil
}
issueIDs.Add(comment.IssueID)
}
- ctx, committer, err := db.TxContext(db.DefaultContext)
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
comments[n] = comment
n++
- if err := comment.LoadResolveDoer(); err != nil {
+ if err := comment.LoadResolveDoer(ctx); err != nil {
return nil, err
}
- if err := comment.LoadReactions(issue.Repo); err != nil {
+ if err := comment.LoadReactions(ctx, issue.Repo); err != nil {
return nil, err
}
Reactions: []*issues_model.Reaction{reaction},
}
- err := issues_model.InsertIssueComments([]*issues_model.Comment{comment})
+ err := issues_model.InsertIssueComments(db.DefaultContext, []*issues_model.Comment{comment})
assert.NoError(t, err)
issueModified := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
Title: title,
Content: content,
}
- err := issues_model.NewIssue(repo, &issue, nil, nil)
+ err := issues_model.NewIssue(db.DefaultContext, repo, &issue, nil, nil)
assert.NoError(t, err)
has, err := db.GetEngine(db.DefaultContext).ID(issue.ID).Get(&newIssue)
}
// ChangeIssueRef changes the branch of this issue, as the given user.
-func ChangeIssueRef(issue *Issue, doer *user_model.User, oldRef string) (err error) {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func ChangeIssueRef(ctx context.Context, issue *Issue, doer *user_model.User, oldRef string) (err error) {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// UpdateIssueAttachments update attachments by UUIDs for the issue
-func UpdateIssueAttachments(issueID int64, uuids []string) (err error) {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func UpdateIssueAttachments(ctx context.Context, issueID int64, uuids []string) (err error) {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// ChangeIssueContent changes issue content, as the given user.
-func ChangeIssueContent(issue *Issue, doer *user_model.User, content string) (err error) {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func ChangeIssueContent(ctx context.Context, issue *Issue, doer *user_model.User, content string) (err error) {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// NewIssue creates new issue with labels for repository.
-func NewIssue(repo *repo_model.Repository, issue *Issue, labelIDs []int64, uuids []string) (err error) {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func NewIssue(ctx context.Context, repo *repo_model.Repository, issue *Issue, labelIDs []int64, uuids []string) (err error) {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
// UpdateIssueByAPI updates all allowed fields of given issue.
// If the issue status is changed a statusChangeComment is returned
// similarly if the title is changed the titleChanged bool is set to true
-func UpdateIssueByAPI(issue *Issue, doer *user_model.User) (statusChangeComment *Comment, titleChanged bool, err error) {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func UpdateIssueByAPI(ctx context.Context, issue *Issue, doer *user_model.User) (statusChangeComment *Comment, titleChanged bool, err error) {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return nil, false, err
}
}
// UpdateIssueDeadline updates an issue deadline and adds comments. Setting a deadline to 0 means deleting it.
-func UpdateIssueDeadline(issue *Issue, deadlineUnix timeutil.TimeStamp, doer *user_model.User) (err error) {
+func UpdateIssueDeadline(ctx context.Context, issue *Issue, deadlineUnix timeutil.TimeStamp, doer *user_model.User) (err error) {
// if the deadline hasn't changed do nothing
if issue.DeadlineUnix == deadlineUnix {
return nil
}
- ctx, committer, err := db.TxContext(db.DefaultContext)
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// UpdateIssuesMigrationsByType updates all migrated repositories' issues from gitServiceType to replace originalAuthorID to posterID
-func UpdateIssuesMigrationsByType(gitServiceType api.GitServiceType, originalAuthorID string, posterID int64) error {
- _, err := db.GetEngine(db.DefaultContext).Table("issue").
+func UpdateIssuesMigrationsByType(ctx context.Context, gitServiceType api.GitServiceType, originalAuthorID string, posterID int64) error {
+ _, err := db.GetEngine(ctx).Table("issue").
Where("repo_id IN (SELECT id FROM repository WHERE original_service_type = ?)", gitServiceType).
And("original_author_id = ?", originalAuthorID).
Update(map[string]any{
}
// UpdateReactionsMigrationsByType updates all migrated repositories' reactions from gitServiceType to replace originalAuthorID to posterID
-func UpdateReactionsMigrationsByType(gitServiceType api.GitServiceType, originalAuthorID string, userID int64) error {
- _, err := db.GetEngine(db.DefaultContext).Table("reaction").
+func UpdateReactionsMigrationsByType(ctx context.Context, gitServiceType api.GitServiceType, originalAuthorID string, userID int64) error {
+ _, err := db.GetEngine(ctx).Table("reaction").
Where("original_author_id = ?", originalAuthorID).
And(migratedIssueCond(gitServiceType)).
Update(map[string]any{
// Remove issue attachment files.
for i := range attachmentPaths {
- system_model.RemoveAllWithNotice(db.DefaultContext, "Delete issue attachment", attachmentPaths[i])
+ system_model.RemoveAllWithNotice(ctx, "Delete issue attachment", attachmentPaths[i])
}
return nil
}
}
// LoadRefComment loads comment that created this reference from database
-func (c *Comment) LoadRefComment() (err error) {
+func (c *Comment) LoadRefComment(ctx context.Context) (err error) {
if c.RefComment != nil {
return nil
}
- c.RefComment, err = GetCommentByID(db.DefaultContext, c.RefCommentID)
+ c.RefComment, err = GetCommentByID(ctx, c.RefCommentID)
return err
}
// LoadRefIssue loads comment that created this reference from database
-func (c *Comment) LoadRefIssue() (err error) {
+func (c *Comment) LoadRefIssue(ctx context.Context) (err error) {
if c.RefIssue != nil {
return nil
}
- c.RefIssue, err = GetIssueByID(db.DefaultContext, c.RefIssueID)
+ c.RefIssue, err = GetIssueByID(ctx, c.RefIssueID)
if err == nil {
- err = c.RefIssue.LoadRepo(db.DefaultContext)
+ err = c.RefIssue.LoadRepo(ctx)
}
return err
}
}
// RefCommentLink returns the relative URL for the comment that created this reference
-func (c *Comment) RefCommentLink() string {
+func (c *Comment) RefCommentLink(ctx context.Context) string {
// Edge case for when the reference is inside the title or the description of the referring issue
if c.RefCommentID == 0 {
- return c.RefIssueLink()
+ return c.RefIssueLink(ctx)
}
- if err := c.LoadRefComment(); err != nil { // Silently dropping errors :unamused:
+ if err := c.LoadRefComment(ctx); err != nil { // Silently dropping errors :unamused:
log.Error("LoadRefComment(%d): %v", c.RefCommentID, err)
return ""
}
- return c.RefComment.Link()
+ return c.RefComment.Link(ctx)
}
// RefIssueLink returns the relative URL of the issue where this reference was created
-func (c *Comment) RefIssueLink() string {
- if err := c.LoadRefIssue(); err != nil { // Silently dropping errors :unamused:
+func (c *Comment) RefIssueLink(ctx context.Context) string {
+ if err := c.LoadRefIssue(ctx); err != nil { // Silently dropping errors :unamused:
log.Error("LoadRefIssue(%d): %v", c.RefCommentID, err)
return ""
}
}
// RefIssueTitle returns the title of the issue where this reference was created
-func (c *Comment) RefIssueTitle() string {
- if err := c.LoadRefIssue(); err != nil { // Silently dropping errors :unamused:
+func (c *Comment) RefIssueTitle(ctx context.Context) string {
+ if err := c.LoadRefIssue(ctx); err != nil { // Silently dropping errors :unamused:
log.Error("LoadRefIssue(%d): %v", c.RefCommentID, err)
return ""
}
}
// RefIssueIdent returns the user friendly identity (e.g. "#1234") of the issue where this reference was created
-func (c *Comment) RefIssueIdent() string {
- if err := c.LoadRefIssue(); err != nil { // Silently dropping errors :unamused:
+func (c *Comment) RefIssueIdent(ctx context.Context) string {
+ if err := c.LoadRefIssue(ctx); err != nil { // Silently dropping errors :unamused:
log.Error("LoadRefIssue(%d): %v", c.RefCommentID, err)
return ""
}
}
// ReviewExists returns whether a review exists for a particular line of code in the PR
-func ReviewExists(issue *Issue, treePath string, line int64) (bool, error) {
- return db.GetEngine(db.DefaultContext).Cols("id").Exist(&Comment{IssueID: issue.ID, TreePath: treePath, Line: line, Type: CommentTypeCode})
+func ReviewExists(ctx context.Context, issue *Issue, treePath string, line int64) (bool, error) {
+ return db.GetEngine(ctx).Cols("id").Exist(&Comment{IssueID: issue.ID, TreePath: treePath, Line: line, Type: CommentTypeCode})
}
// ContentEmptyErr represents an content empty error
}
// SubmitReview creates a review out of the existing pending review or creates a new one if no pending review exist
-func SubmitReview(doer *user_model.User, issue *Issue, reviewType ReviewType, content, commitID string, stale bool, attachmentUUIDs []string) (*Review, *Comment, error) {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func SubmitReview(ctx context.Context, doer *user_model.User, issue *Issue, reviewType ReviewType, content, commitID string, stale bool, attachmentUUIDs []string) (*Review, *Comment, error) {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return nil, nil, err
}
}
// MarkReviewsAsStale marks existing reviews as stale
-func MarkReviewsAsStale(issueID int64) (err error) {
- _, err = db.GetEngine(db.DefaultContext).Exec("UPDATE `review` SET stale=? WHERE issue_id=?", true, issueID)
+func MarkReviewsAsStale(ctx context.Context, issueID int64) (err error) {
+ _, err = db.GetEngine(ctx).Exec("UPDATE `review` SET stale=? WHERE issue_id=?", true, issueID)
return err
}
// MarkReviewsAsNotStale marks existing reviews as not stale for a giving commit SHA
-func MarkReviewsAsNotStale(issueID int64, commitID string) (err error) {
- _, err = db.GetEngine(db.DefaultContext).Exec("UPDATE `review` SET stale=? WHERE issue_id=? AND commit_id=?", false, issueID, commitID)
+func MarkReviewsAsNotStale(ctx context.Context, issueID int64, commitID string) (err error) {
+ _, err = db.GetEngine(ctx).Exec("UPDATE `review` SET stale=? WHERE issue_id=? AND commit_id=?", false, issueID, commitID)
return err
}
}
// InsertReviews inserts review and review comments
-func InsertReviews(reviews []*Review) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func InsertReviews(ctx context.Context, reviews []*Review) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// MarkConversation Add or remove Conversation mark for a code comment
-func MarkConversation(comment *Comment, doer *user_model.User, isResolve bool) (err error) {
+func MarkConversation(ctx context.Context, comment *Comment, doer *user_model.User, isResolve bool) (err error) {
if comment.Type != CommentTypeCode {
return nil
}
return nil
}
- if _, err = db.GetEngine(db.DefaultContext).Exec("UPDATE `comment` SET resolve_doer_id=? WHERE id=?", doer.ID, comment.ID); err != nil {
+ if _, err = db.GetEngine(ctx).Exec("UPDATE `comment` SET resolve_doer_id=? WHERE id=?", doer.ID, comment.ID); err != nil {
return err
}
} else {
return nil
}
- if _, err = db.GetEngine(db.DefaultContext).Exec("UPDATE `comment` SET resolve_doer_id=? WHERE id=?", 0, comment.ID); err != nil {
+ if _, err = db.GetEngine(ctx).Exec("UPDATE `comment` SET resolve_doer_id=? WHERE id=?", 0, comment.ID); err != nil {
return err
}
}
// CanMarkConversation Add or remove Conversation mark for a code comment permission check
// the PR writer , offfcial reviewer and poster can do it
-func CanMarkConversation(issue *Issue, doer *user_model.User) (permResult bool, err error) {
+func CanMarkConversation(ctx context.Context, issue *Issue, doer *user_model.User) (permResult bool, err error) {
if doer == nil || issue == nil {
return false, fmt.Errorf("issue or doer is nil")
}
if doer.ID != issue.PosterID {
- if err = issue.LoadRepo(db.DefaultContext); err != nil {
+ if err = issue.LoadRepo(ctx); err != nil {
return false, err
}
- p, err := access_model.GetUserRepoPermission(db.DefaultContext, issue.Repo, doer)
+ p, err := access_model.GetUserRepoPermission(ctx, issue.Repo, doer)
if err != nil {
return false, err
}
permResult = p.CanAccess(perm.AccessModeWrite, unit.TypePullRequests)
if !permResult {
- if permResult, err = IsOfficialReviewer(db.DefaultContext, issue, doer); err != nil {
+ if permResult, err = IsOfficialReviewer(ctx, issue, doer); err != nil {
return false, err
}
}
}
// DeleteReview delete a review and it's code comments
-func DeleteReview(r *Review) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func DeleteReview(ctx context.Context, r *Review) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// GetCodeCommentsCount return count of CodeComments a Review has
-func (r *Review) GetCodeCommentsCount() int {
+func (r *Review) GetCodeCommentsCount(ctx context.Context) int {
opts := FindCommentsOptions{
Type: CommentTypeCode,
IssueID: r.IssueID,
conds = conds.And(builder.Eq{"invalidated": false})
}
- count, err := db.GetEngine(db.DefaultContext).Where(conds).Count(new(Comment))
+ count, err := db.GetEngine(ctx).Where(conds).Count(new(Comment))
if err != nil {
return 0
}
}
// HTMLURL formats a URL-string to the related review issue-comment
-func (r *Review) HTMLURL() string {
+func (r *Review) HTMLURL(ctx context.Context) string {
opts := FindCommentsOptions{
Type: CommentTypeReview,
IssueID: r.IssueID,
ReviewID: r.ID,
}
comment := new(Comment)
- has, err := db.GetEngine(db.DefaultContext).Where(opts.ToConds()).Get(comment)
+ has, err := db.GetEngine(ctx).Where(opts.ToConds()).Get(comment)
if err != nil || !has {
return ""
}
- return comment.HTMLURL()
+ return comment.HTMLURL(ctx)
}
// RemapExternalUser ExternalUserRemappable interface
func (r *Review) GetExternalID() int64 { return r.OriginalAuthorID }
// UpdateReviewsMigrationsByType updates reviews' migrations information via given git service type and original id and poster id
-func UpdateReviewsMigrationsByType(tp structs.GitServiceType, originalAuthorID string, posterID int64) error {
- _, err := db.GetEngine(db.DefaultContext).Table("review").
+func UpdateReviewsMigrationsByType(ctx context.Context, tp structs.GitServiceType, originalAuthorID string, posterID int64) error {
+ _, err := db.GetEngine(ctx).Table("review").
Where("original_author_id = ?", originalAuthorID).
And(migratedIssueCond(tp)).
Update(map[string]any{
})
assert.NoError(t, err)
- assert.NoError(t, issues_model.DeleteReview(review2))
+ assert.NoError(t, issues_model.DeleteReview(db.DefaultContext, review2))
_, err = issues_model.GetReviewByID(db.DefaultContext, review2.ID)
assert.Error(t, err)
}
// NumIssues return counter of all issues assigned to the board
-func (b *Board) NumIssues() int {
- c, err := db.GetEngine(db.DefaultContext).Table("project_issue").
+func (b *Board) NumIssues(ctx context.Context) int {
+ c, err := db.GetEngine(ctx).Table("project_issue").
Where("project_id=?", b.ProjectID).
And("project_board_id=?", b.ID).
GroupBy("issue_id").
}
// NewBoard adds a new project board to a given project
-func NewBoard(board *Board) error {
+func NewBoard(ctx context.Context, board *Board) error {
if len(board.Color) != 0 && !BoardColorPattern.MatchString(board.Color) {
return fmt.Errorf("bad color code: %s", board.Color)
}
- _, err := db.GetEngine(db.DefaultContext).Insert(board)
+ _, err := db.GetEngine(ctx).Insert(board)
return err
}
// DeleteBoardByID removes all issues references to the project board.
-func DeleteBoardByID(boardID int64) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func DeleteBoardByID(ctx context.Context, boardID int64) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
// SetDefaultBoard represents a board for issues not assigned to one
// if boardID is 0 unset default
-func SetDefaultBoard(projectID, boardID int64) error {
- _, err := db.GetEngine(db.DefaultContext).Where(builder.Eq{
+func SetDefaultBoard(ctx context.Context, projectID, boardID int64) error {
+ _, err := db.GetEngine(ctx).Where(builder.Eq{
"project_id": projectID,
"`default`": true,
}).Cols("`default`").Update(&Board{Default: false})
}
if boardID > 0 {
- _, err = db.GetEngine(db.DefaultContext).ID(boardID).Where(builder.Eq{"project_id": projectID}).
+ _, err = db.GetEngine(ctx).ID(boardID).Where(builder.Eq{"project_id": projectID}).
Cols("`default`").Update(&Board{Default: true})
}
}
// UpdateBoardSorting update project board sorting
-func UpdateBoardSorting(bs BoardList) error {
+func UpdateBoardSorting(ctx context.Context, bs BoardList) error {
for i := range bs {
- _, err := db.GetEngine(db.DefaultContext).ID(bs[i].ID).Cols(
+ _, err := db.GetEngine(ctx).ID(bs[i].ID).Cols(
"sorting",
).Update(bs[i])
if err != nil {
}
// NumIssues return counter of all issues assigned to a project
-func (p *Project) NumIssues() int {
- c, err := db.GetEngine(db.DefaultContext).Table("project_issue").
+func (p *Project) NumIssues(ctx context.Context) int {
+ c, err := db.GetEngine(ctx).Table("project_issue").
Where("project_id=?", p.ID).
GroupBy("issue_id").
Cols("issue_id").
}
// NumClosedIssues return counter of closed issues assigned to a project
-func (p *Project) NumClosedIssues() int {
- c, err := db.GetEngine(db.DefaultContext).Table("project_issue").
+func (p *Project) NumClosedIssues(ctx context.Context) int {
+ c, err := db.GetEngine(ctx).Table("project_issue").
Join("INNER", "issue", "project_issue.issue_id=issue.id").
Where("project_issue.project_id=? AND issue.is_closed=?", p.ID, true).
Cols("issue_id").
}
// NumOpenIssues return counter of open issues assigned to a project
-func (p *Project) NumOpenIssues() int {
- c, err := db.GetEngine(db.DefaultContext).Table("project_issue").
+func (p *Project) NumOpenIssues(ctx context.Context) int {
+ c, err := db.GetEngine(ctx).Table("project_issue").
Join("INNER", "issue", "project_issue.issue_id=issue.id").
Where("project_issue.project_id=? AND issue.is_closed=?", p.ID, false).
Cols("issue_id").
}
// MoveIssuesOnProjectBoard moves or keeps issues in a column and sorts them inside that column
-func MoveIssuesOnProjectBoard(board *Board, sortedIssueIDs map[int64]int64) error {
- return db.WithTx(db.DefaultContext, func(ctx context.Context) error {
+func MoveIssuesOnProjectBoard(ctx context.Context, board *Board, sortedIssueIDs map[int64]int64) error {
+ return db.WithTx(ctx, func(ctx context.Context) error {
sess := db.GetEngine(ctx)
issueIDs := make([]int64, 0, len(sortedIssueIDs))
}
// Link returns the project's relative URL.
-func (p *Project) Link() string {
+func (p *Project) Link(ctx context.Context) string {
if p.OwnerID > 0 {
- err := p.LoadOwner(db.DefaultContext)
+ err := p.LoadOwner(ctx)
if err != nil {
log.Error("LoadOwner: %v", err)
return ""
return fmt.Sprintf("%s/-/projects/%d", p.Owner.HomeLink(), p.ID)
}
if p.RepoID > 0 {
- err := p.LoadRepo(db.DefaultContext)
+ err := p.LoadRepo(ctx)
if err != nil {
log.Error("LoadRepo: %v", err)
return ""
}
// NewProject creates a new Project
-func NewProject(p *Project) error {
+func NewProject(ctx context.Context, p *Project) error {
if !IsBoardTypeValid(p.BoardType) {
p.BoardType = BoardTypeNone
}
return util.NewInvalidArgumentErrorf("project type is not valid")
}
- ctx, committer, err := db.TxContext(db.DefaultContext)
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// ChangeProjectStatusByRepoIDAndID toggles a project between opened and closed
-func ChangeProjectStatusByRepoIDAndID(repoID, projectID int64, isClosed bool) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func ChangeProjectStatusByRepoIDAndID(ctx context.Context, repoID, projectID int64, isClosed bool) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
}
// ChangeProjectStatus toggle a project between opened and closed
-func ChangeProjectStatus(p *Project, isClosed bool) error {
- ctx, committer, err := db.TxContext(db.DefaultContext)
+func ChangeProjectStatus(ctx context.Context, p *Project, isClosed bool) error {
+ ctx, committer, err := db.TxContext(ctx)
if err != nil {
return err
}
CreatorID: 2,
}
- assert.NoError(t, NewProject(project))
+ assert.NoError(t, NewProject(db.DefaultContext, project))
_, err := GetProjectByID(db.DefaultContext, project.ID)
assert.NoError(t, err)
assert.Equal(t, project.Title, projectFromDB.Title)
- assert.NoError(t, ChangeProjectStatus(project, true))
+ assert.NoError(t, ChangeProjectStatus(db.DefaultContext, project, true))
// Retrieve from DB afresh to check if it is truly closed
projectFromDB, err = GetProjectByID(db.DefaultContext, project.ID)
}
// CountCollaborators returns total number of collaborators for a repository
-func CountCollaborators(repoID int64) (int64, error) {
- return db.GetEngine(db.DefaultContext).Where("repo_id = ? ", repoID).Count(&Collaboration{})
+func CountCollaborators(ctx context.Context, repoID int64) (int64, error) {
+ return db.GetEngine(ctx).Where("repo_id = ? ", repoID).Count(&Collaboration{})
}
// GetCollaboration get collaboration for a repository id with a user id
}
// IsOwnerMemberCollaborator checks if a provided user is the owner, a collaborator or a member of a team in a repository
-func IsOwnerMemberCollaborator(repo *Repository, userID int64) (bool, error) {
+func IsOwnerMemberCollaborator(ctx context.Context, repo *Repository, userID int64) (bool, error) {
if repo.OwnerID == userID {
return true, nil
}
- teamMember, err := db.GetEngine(db.DefaultContext).Join("INNER", "team_repo", "team_repo.team_id = team_user.team_id").
+ teamMember, err := db.GetEngine(ctx).Join("INNER", "team_repo", "team_repo.team_id = team_user.team_id").
Join("INNER", "team_unit", "team_unit.team_id = team_user.team_id").
Where("team_repo.repo_id = ?", repo.ID).
And("team_unit.`type` = ?", unit.TypeCode).
return true, nil
}
- return db.GetEngine(db.DefaultContext).Get(&Collaboration{RepoID: repo.ID, UserID: userID})
+ return db.GetEngine(ctx).Get(&Collaboration{RepoID: repo.ID, UserID: userID})
}
assert.NoError(t, unittest.PrepareTestDatabase())
repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
- count, err := repo_model.CountCollaborators(repo1.ID)
+ count, err := repo_model.CountCollaborators(db.DefaultContext, repo1.ID)
assert.NoError(t, err)
assert.EqualValues(t, 2, count)
repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 22})
- count, err = repo_model.CountCollaborators(repo2.ID)
+ count, err = repo_model.CountCollaborators(db.DefaultContext, repo2.ID)
assert.NoError(t, err)
assert.EqualValues(t, 2, count)
// Non-existent repository.
- count, err = repo_model.CountCollaborators(unittest.NonexistentID)
+ count, err = repo_model.CountCollaborators(db.DefaultContext, unittest.NonexistentID)
assert.NoError(t, err)
assert.EqualValues(t, 0, count)
}
repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
// Organisation owner.
- actual, err := repo_model.IsOwnerMemberCollaborator(repo1, 2)
+ actual, err := repo_model.IsOwnerMemberCollaborator(db.DefaultContext, repo1, 2)
assert.NoError(t, err)
assert.True(t, actual)
// Team member.
- actual, err = repo_model.IsOwnerMemberCollaborator(repo1, 4)
+ actual, err = repo_model.IsOwnerMemberCollaborator(db.DefaultContext, repo1, 4)
assert.NoError(t, err)
assert.True(t, actual)
// Normal user.
- actual, err = repo_model.IsOwnerMemberCollaborator(repo1, 1)
+ actual, err = repo_model.IsOwnerMemberCollaborator(db.DefaultContext, repo1, 1)
assert.NoError(t, err)
assert.False(t, actual)
repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
// Collaborator.
- actual, err = repo_model.IsOwnerMemberCollaborator(repo2, 4)
+ actual, err = repo_model.IsOwnerMemberCollaborator(db.DefaultContext, repo2, 4)
assert.NoError(t, err)
assert.True(t, actual)
repo3 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 15})
// Repository owner.
- actual, err = repo_model.IsOwnerMemberCollaborator(repo3, 2)
+ actual, err = repo_model.IsOwnerMemberCollaborator(db.DefaultContext, repo3, 2)
assert.NoError(t, err)
assert.True(t, actual)
}
}
// GetRepository returns the repository.
-func (m *Mirror) GetRepository() *Repository {
+func (m *Mirror) GetRepository(ctx context.Context) *Repository {
if m.Repo != nil {
return m.Repo
}
var err error
- m.Repo, err = GetRepositoryByID(db.DefaultContext, m.RepoID)
+ m.Repo, err = GetRepositoryByID(ctx, m.RepoID)
if err != nil {
log.Error("getRepositoryByID[%d]: %v", m.ID, err)
}
}
// DeleteMirrorByRepoID deletes a mirror by repoID
-func DeleteMirrorByRepoID(repoID int64) error {
- _, err := db.GetEngine(db.DefaultContext).Delete(&Mirror{RepoID: repoID})
+func DeleteMirrorByRepoID(ctx context.Context, repoID int64) error {
+ _, err := db.GetEngine(ctx).Delete(&Mirror{RepoID: repoID})
return err
}
// MirrorsIterate iterates all mirror repositories.
-func MirrorsIterate(limit int, f func(idx int, bean any) error) error {
- sess := db.GetEngine(db.DefaultContext).
+func MirrorsIterate(ctx context.Context, limit int, f func(idx int, bean any) error) error {
+ sess := db.GetEngine(ctx).
Where("next_update_unix<=?", time.Now().Unix()).
And("next_update_unix!=0").
OrderBy("updated_unix ASC")
now := timeutil.TimeStampNow().Add(-2)
- uidCounts, err := activities_model.GetUIDsAndNotificationCounts(then, now)
+ uidCounts, err := activities_model.GetUIDsAndNotificationCounts(ctx, then, now)
if err != nil {
log.Error("Unable to get UIDcounts: %v", err)
}
c.Verification = asymkey_model.ParseCommitWithSignature(ctx, c.Commit)
_ = asymkey_model.CalculateTrustStatus(c.Verification, repository.GetTrustModel(), func(user *user_model.User) (bool, error) {
- return repo_model.IsOwnerMemberCollaborator(repository, user.ID)
+ return repo_model.IsOwnerMemberCollaborator(ctx, repository, user.ID)
}, &keyMap)
statuses, _, err := git_model.GetLatestCommitStatus(ctx, repository.ID, c.Commit.ID.String(), db.ListOptions{})
// Actioner describes an action
type Actioner interface {
GetOpType() activities_model.ActionType
- GetActUserName() string
- GetRepoUserName() string
- GetRepoName() string
- GetRepoPath() string
- GetRepoLink() string
+ GetActUserName(ctx context.Context) string
+ GetRepoUserName(ctx context.Context) string
+ GetRepoName(ctx context.Context) string
+ GetRepoPath(ctx context.Context) string
+ GetRepoLink(ctx context.Context) string
GetBranch() string
GetContent() string
GetCreate() time.Time
usersActiveHalfyear := int(user_model.CountUsers(ctx, &user_model.CountUserFilter{LastLoginSince: &timeHaveYearAgo}))
allIssues, _ := issues_model.CountIssues(ctx, &issues_model.IssuesOptions{})
- allComments, _ := issues_model.CountComments(&issues_model.FindCommentsOptions{})
+ allComments, _ := issues_model.CountComments(ctx, &issues_model.FindCommentsOptions{})
nodeInfoUsage = structs.NodeInfoUsage{
Users: structs.NodeInfoUsageUsers{
ctx.SetTotalCountHeader(totalCount)
- ctx.JSON(http.StatusOK, convert.ToNotifications(nl))
+ ctx.JSON(http.StatusOK, convert.ToNotifications(ctx, nl))
}
// ReadRepoNotifications mark notification threads as read on a specific repo
return
}
_ = notif.LoadAttributes(ctx)
- changed = append(changed, convert.ToNotificationThread(notif))
+ changed = append(changed, convert.ToNotificationThread(ctx, notif))
}
ctx.JSON(http.StatusResetContent, changed)
}
return
}
- ctx.JSON(http.StatusOK, convert.ToNotificationThread(n))
+ ctx.JSON(http.StatusOK, convert.ToNotificationThread(ctx, n))
}
// ReadThread mark notification as read by ID
ctx.InternalServerError(err)
return
}
- ctx.JSON(http.StatusResetContent, convert.ToNotificationThread(notif))
+ ctx.JSON(http.StatusResetContent, convert.ToNotificationThread(ctx, notif))
}
func getThread(ctx *context.APIContext) *activities_model.Notification {
}
ctx.SetTotalCountHeader(totalCount)
- ctx.JSON(http.StatusOK, convert.ToNotifications(nl))
+ ctx.JSON(http.StatusOK, convert.ToNotifications(ctx, nl))
}
// ReadNotifications mark notification threads as read, unread, or pinned
return
}
_ = notif.LoadAttributes(ctx)
- changed = append(changed, convert.ToNotificationThread(notif))
+ changed = append(changed, convert.ToNotificationThread(ctx, notif))
}
ctx.JSON(http.StatusResetContent, changed)
// "404":
// "$ref": "#/responses/notFound"
- count, err := repo_model.CountCollaborators(ctx.Repo.Repository.ID)
+ count, err := repo_model.CountCollaborators(ctx, ctx.Repo.Repository.ID)
if err != nil {
ctx.InternalServerError(err)
return
deadlineUnix = timeutil.TimeStamp(deadline.Unix())
}
- if err := issues_model.UpdateIssueDeadline(issue, deadlineUnix, ctx.Doer); err != nil {
+ if err := issues_model.UpdateIssueDeadline(ctx, issue, deadlineUnix, ctx.Doer); err != nil {
ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err)
return
}
}
issue.IsClosed = api.StateClosed == api.StateType(*form.State)
}
- statusChangeComment, titleChanged, err := issues_model.UpdateIssueByAPI(issue, ctx.Doer)
+ statusChangeComment, titleChanged, err := issues_model.UpdateIssueByAPI(ctx, issue, ctx.Doer)
if err != nil {
if issues_model.IsErrDependenciesLeft(err) {
ctx.Error(http.StatusPreconditionFailed, "DependenciesLeft", "cannot close this issue because it still has open dependencies")
deadlineUnix = timeutil.TimeStamp(deadline.Unix())
}
- if err := issues_model.UpdateIssueDeadline(issue, deadlineUnix, ctx.Doer); err != nil {
+ if err := issues_model.UpdateIssueDeadline(ctx, issue, deadlineUnix, ctx.Doer); err != nil {
ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err)
return
}
return
}
- totalCount, err := issues_model.CountComments(opts)
+ totalCount, err := issues_model.CountComments(ctx, opts)
if err != nil {
ctx.InternalServerError(err)
return
return
}
- totalCount, err := issues_model.CountComments(opts)
+ totalCount, err := issues_model.CountComments(ctx, opts)
if err != nil {
ctx.InternalServerError(err)
return
deadlineUnix = timeutil.TimeStamp(deadline.Unix())
}
- if err := issues_model.UpdateIssueDeadline(issue, deadlineUnix, ctx.Doer); err != nil {
+ if err := issues_model.UpdateIssueDeadline(ctx, issue, deadlineUnix, ctx.Doer); err != nil {
ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err)
return
}
}
issue.IsClosed = api.StateClosed == api.StateType(*form.State)
}
- statusChangeComment, titleChanged, err := issues_model.UpdateIssueByAPI(issue, ctx.Doer)
+ statusChangeComment, titleChanged, err := issues_model.UpdateIssueByAPI(ctx, issue, ctx.Doer)
if err != nil {
if issues_model.IsErrDependenciesLeft(err) {
ctx.Error(http.StatusPreconditionFailed, "DependenciesLeft", "cannot close this pull request because it still has open dependencies")
return
}
- if err := issues_model.DeleteReview(review); err != nil {
+ if err := issues_model.DeleteReview(ctx, review); err != nil {
ctx.Error(http.StatusInternalServerError, "DeleteReview", fmt.Errorf("can not delete ReviewID: %d", review.ID))
return
}
}
if comment != nil && isAdd {
- if err = comment.LoadReview(); err != nil {
+ if err = comment.LoadReview(ctx); err != nil {
ctx.ServerError("ReviewRequest", err)
return
}
}
if comment != nil && isAdd {
- if err = comment.LoadReview(); err != nil {
+ if err = comment.LoadReview(ctx); err != nil {
ctx.ServerError("ReviewRequest", err)
return
}
"github.com/gorilla/feeds"
)
-func toBranchLink(act *activities_model.Action) string {
- return act.GetRepoAbsoluteLink() + "/src/branch/" + util.PathEscapeSegments(act.GetBranch())
+func toBranchLink(ctx *context.Context, act *activities_model.Action) string {
+ return act.GetRepoAbsoluteLink(ctx) + "/src/branch/" + util.PathEscapeSegments(act.GetBranch())
}
-func toTagLink(act *activities_model.Action) string {
- return act.GetRepoAbsoluteLink() + "/src/tag/" + util.PathEscapeSegments(act.GetTag())
+func toTagLink(ctx *context.Context, act *activities_model.Action) string {
+ return act.GetRepoAbsoluteLink(ctx) + "/src/tag/" + util.PathEscapeSegments(act.GetTag())
}
-func toIssueLink(act *activities_model.Action) string {
- return act.GetRepoAbsoluteLink() + "/issues/" + url.PathEscape(act.GetIssueInfos()[0])
+func toIssueLink(ctx *context.Context, act *activities_model.Action) string {
+ return act.GetRepoAbsoluteLink(ctx) + "/issues/" + url.PathEscape(act.GetIssueInfos()[0])
}
-func toPullLink(act *activities_model.Action) string {
- return act.GetRepoAbsoluteLink() + "/pulls/" + url.PathEscape(act.GetIssueInfos()[0])
+func toPullLink(ctx *context.Context, act *activities_model.Action) string {
+ return act.GetRepoAbsoluteLink(ctx) + "/pulls/" + url.PathEscape(act.GetIssueInfos()[0])
}
-func toSrcLink(act *activities_model.Action) string {
- return act.GetRepoAbsoluteLink() + "/src/" + util.PathEscapeSegments(act.GetBranch())
+func toSrcLink(ctx *context.Context, act *activities_model.Action) string {
+ return act.GetRepoAbsoluteLink(ctx) + "/src/" + util.PathEscapeSegments(act.GetBranch())
}
-func toReleaseLink(act *activities_model.Action) string {
- return act.GetRepoAbsoluteLink() + "/releases/tag/" + util.PathEscapeSegments(act.GetBranch())
+func toReleaseLink(ctx *context.Context, act *activities_model.Action) string {
+ return act.GetRepoAbsoluteLink(ctx) + "/releases/tag/" + util.PathEscapeSegments(act.GetBranch())
}
// renderMarkdown creates a minimal markdown render context from an action.
func renderMarkdown(ctx *context.Context, act *activities_model.Action, content string) string {
markdownCtx := &markup.RenderContext{
Ctx: ctx,
- URLPrefix: act.GetRepoLink(),
+ URLPrefix: act.GetRepoLink(ctx),
Type: markdown.MarkupName,
Metas: map[string]string{
- "user": act.GetRepoUserName(),
- "repo": act.GetRepoName(),
+ "user": act.GetRepoUserName(ctx),
+ "repo": act.GetRepoName(ctx),
},
}
markdown, err := markdown.RenderString(markdownCtx, content)
var content, desc, title string
- link := &feeds.Link{Href: act.GetCommentHTMLURL()}
+ link := &feeds.Link{Href: act.GetCommentHTMLURL(ctx)}
// title
title = act.ActUser.DisplayName() + " "
switch act.OpType {
case activities_model.ActionCreateRepo:
- title += ctx.TrHTMLEscapeArgs("action.create_repo", act.GetRepoAbsoluteLink(), act.ShortRepoPath())
- link.Href = act.GetRepoAbsoluteLink()
+ title += ctx.TrHTMLEscapeArgs("action.create_repo", act.GetRepoAbsoluteLink(ctx), act.ShortRepoPath(ctx))
+ link.Href = act.GetRepoAbsoluteLink(ctx)
case activities_model.ActionRenameRepo:
- title += ctx.TrHTMLEscapeArgs("action.rename_repo", act.GetContent(), act.GetRepoAbsoluteLink(), act.ShortRepoPath())
- link.Href = act.GetRepoAbsoluteLink()
+ title += ctx.TrHTMLEscapeArgs("action.rename_repo", act.GetContent(), act.GetRepoAbsoluteLink(ctx), act.ShortRepoPath(ctx))
+ link.Href = act.GetRepoAbsoluteLink(ctx)
case activities_model.ActionCommitRepo:
- link.Href = toBranchLink(act)
+ link.Href = toBranchLink(ctx, act)
if len(act.Content) != 0 {
- title += ctx.TrHTMLEscapeArgs("action.commit_repo", act.GetRepoAbsoluteLink(), link.Href, act.GetBranch(), act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.commit_repo", act.GetRepoAbsoluteLink(ctx), link.Href, act.GetBranch(), act.ShortRepoPath(ctx))
} else {
- title += ctx.TrHTMLEscapeArgs("action.create_branch", act.GetRepoAbsoluteLink(), link.Href, act.GetBranch(), act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.create_branch", act.GetRepoAbsoluteLink(ctx), link.Href, act.GetBranch(), act.ShortRepoPath(ctx))
}
case activities_model.ActionCreateIssue:
- link.Href = toIssueLink(act)
- title += ctx.TrHTMLEscapeArgs("action.create_issue", link.Href, act.GetIssueInfos()[0], act.ShortRepoPath())
+ link.Href = toIssueLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.create_issue", link.Href, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionCreatePullRequest:
- link.Href = toPullLink(act)
- title += ctx.TrHTMLEscapeArgs("action.create_pull_request", link.Href, act.GetIssueInfos()[0], act.ShortRepoPath())
+ link.Href = toPullLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.create_pull_request", link.Href, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionTransferRepo:
- link.Href = act.GetRepoAbsoluteLink()
- title += ctx.TrHTMLEscapeArgs("action.transfer_repo", act.GetContent(), act.GetRepoAbsoluteLink(), act.ShortRepoPath())
+ link.Href = act.GetRepoAbsoluteLink(ctx)
+ title += ctx.TrHTMLEscapeArgs("action.transfer_repo", act.GetContent(), act.GetRepoAbsoluteLink(ctx), act.ShortRepoPath(ctx))
case activities_model.ActionPushTag:
- link.Href = toTagLink(act)
- title += ctx.TrHTMLEscapeArgs("action.push_tag", act.GetRepoAbsoluteLink(), link.Href, act.GetTag(), act.ShortRepoPath())
+ link.Href = toTagLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.push_tag", act.GetRepoAbsoluteLink(ctx), link.Href, act.GetTag(), act.ShortRepoPath(ctx))
case activities_model.ActionCommentIssue:
- issueLink := toIssueLink(act)
+ issueLink := toIssueLink(ctx, act)
if link.Href == "#" {
link.Href = issueLink
}
- title += ctx.TrHTMLEscapeArgs("action.comment_issue", issueLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.comment_issue", issueLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionMergePullRequest:
- pullLink := toPullLink(act)
+ pullLink := toPullLink(ctx, act)
if link.Href == "#" {
link.Href = pullLink
}
- title += ctx.TrHTMLEscapeArgs("action.merge_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.merge_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionAutoMergePullRequest:
- pullLink := toPullLink(act)
+ pullLink := toPullLink(ctx, act)
if link.Href == "#" {
link.Href = pullLink
}
- title += ctx.TrHTMLEscapeArgs("action.auto_merge_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.auto_merge_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionCloseIssue:
- issueLink := toIssueLink(act)
+ issueLink := toIssueLink(ctx, act)
if link.Href == "#" {
link.Href = issueLink
}
- title += ctx.TrHTMLEscapeArgs("action.close_issue", issueLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.close_issue", issueLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionReopenIssue:
- issueLink := toIssueLink(act)
+ issueLink := toIssueLink(ctx, act)
if link.Href == "#" {
link.Href = issueLink
}
- title += ctx.TrHTMLEscapeArgs("action.reopen_issue", issueLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.reopen_issue", issueLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionClosePullRequest:
- pullLink := toPullLink(act)
+ pullLink := toPullLink(ctx, act)
if link.Href == "#" {
link.Href = pullLink
}
- title += ctx.TrHTMLEscapeArgs("action.close_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.close_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionReopenPullRequest:
- pullLink := toPullLink(act)
+ pullLink := toPullLink(ctx, act)
if link.Href == "#" {
link.Href = pullLink
}
- title += ctx.TrHTMLEscapeArgs("action.reopen_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.reopen_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionDeleteTag:
- link.Href = act.GetRepoAbsoluteLink()
- title += ctx.TrHTMLEscapeArgs("action.delete_tag", act.GetRepoAbsoluteLink(), act.GetTag(), act.ShortRepoPath())
+ link.Href = act.GetRepoAbsoluteLink(ctx)
+ title += ctx.TrHTMLEscapeArgs("action.delete_tag", act.GetRepoAbsoluteLink(ctx), act.GetTag(), act.ShortRepoPath(ctx))
case activities_model.ActionDeleteBranch:
- link.Href = act.GetRepoAbsoluteLink()
- title += ctx.TrHTMLEscapeArgs("action.delete_branch", act.GetRepoAbsoluteLink(), html.EscapeString(act.GetBranch()), act.ShortRepoPath())
+ link.Href = act.GetRepoAbsoluteLink(ctx)
+ title += ctx.TrHTMLEscapeArgs("action.delete_branch", act.GetRepoAbsoluteLink(ctx), html.EscapeString(act.GetBranch()), act.ShortRepoPath(ctx))
case activities_model.ActionMirrorSyncPush:
- srcLink := toSrcLink(act)
+ srcLink := toSrcLink(ctx, act)
if link.Href == "#" {
link.Href = srcLink
}
- title += ctx.TrHTMLEscapeArgs("action.mirror_sync_push", act.GetRepoAbsoluteLink(), srcLink, act.GetBranch(), act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.mirror_sync_push", act.GetRepoAbsoluteLink(ctx), srcLink, act.GetBranch(), act.ShortRepoPath(ctx))
case activities_model.ActionMirrorSyncCreate:
- srcLink := toSrcLink(act)
+ srcLink := toSrcLink(ctx, act)
if link.Href == "#" {
link.Href = srcLink
}
- title += ctx.TrHTMLEscapeArgs("action.mirror_sync_create", act.GetRepoAbsoluteLink(), srcLink, act.GetBranch(), act.ShortRepoPath())
+ title += ctx.TrHTMLEscapeArgs("action.mirror_sync_create", act.GetRepoAbsoluteLink(ctx), srcLink, act.GetBranch(), act.ShortRepoPath(ctx))
case activities_model.ActionMirrorSyncDelete:
- link.Href = act.GetRepoAbsoluteLink()
- title += ctx.TrHTMLEscapeArgs("action.mirror_sync_delete", act.GetRepoAbsoluteLink(), act.GetBranch(), act.ShortRepoPath())
+ link.Href = act.GetRepoAbsoluteLink(ctx)
+ title += ctx.TrHTMLEscapeArgs("action.mirror_sync_delete", act.GetRepoAbsoluteLink(ctx), act.GetBranch(), act.ShortRepoPath(ctx))
case activities_model.ActionApprovePullRequest:
- pullLink := toPullLink(act)
- title += ctx.TrHTMLEscapeArgs("action.approve_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ pullLink := toPullLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.approve_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionRejectPullRequest:
- pullLink := toPullLink(act)
- title += ctx.TrHTMLEscapeArgs("action.reject_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ pullLink := toPullLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.reject_pull_request", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionCommentPull:
- pullLink := toPullLink(act)
- title += ctx.TrHTMLEscapeArgs("action.comment_pull", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath())
+ pullLink := toPullLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.comment_pull", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx))
case activities_model.ActionPublishRelease:
- releaseLink := toReleaseLink(act)
+ releaseLink := toReleaseLink(ctx, act)
if link.Href == "#" {
link.Href = releaseLink
}
- title += ctx.TrHTMLEscapeArgs("action.publish_release", act.GetRepoAbsoluteLink(), releaseLink, act.ShortRepoPath(), act.Content)
+ title += ctx.TrHTMLEscapeArgs("action.publish_release", act.GetRepoAbsoluteLink(ctx), releaseLink, act.ShortRepoPath(ctx), act.Content)
case activities_model.ActionPullReviewDismissed:
- pullLink := toPullLink(act)
- title += ctx.TrHTMLEscapeArgs("action.review_dismissed", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(), act.GetIssueInfos()[1])
+ pullLink := toPullLink(ctx, act)
+ title += ctx.TrHTMLEscapeArgs("action.review_dismissed", pullLink, act.GetIssueInfos()[0], act.ShortRepoPath(ctx), act.GetIssueInfos()[1])
case activities_model.ActionStarRepo:
- link.Href = act.GetRepoAbsoluteLink()
- title += ctx.TrHTMLEscapeArgs("action.starred_repo", act.GetRepoAbsoluteLink(), act.GetRepoPath())
+ link.Href = act.GetRepoAbsoluteLink(ctx)
+ title += ctx.TrHTMLEscapeArgs("action.starred_repo", act.GetRepoAbsoluteLink(ctx), act.GetRepoPath(ctx))
case activities_model.ActionWatchRepo:
- link.Href = act.GetRepoAbsoluteLink()
- title += ctx.TrHTMLEscapeArgs("action.watched_repo", act.GetRepoAbsoluteLink(), act.GetRepoPath())
+ link.Href = act.GetRepoAbsoluteLink(ctx)
+ title += ctx.TrHTMLEscapeArgs("action.watched_repo", act.GetRepoAbsoluteLink(ctx), act.GetRepoPath(ctx))
default:
return nil, fmt.Errorf("unknown action type: %v", act.OpType)
}
switch act.OpType {
case activities_model.ActionCommitRepo, activities_model.ActionMirrorSyncPush:
push := templates.ActionContent2Commits(act)
- repoLink := act.GetRepoAbsoluteLink()
+ repoLink := act.GetRepoAbsoluteLink(ctx)
for _, commit := range push.Commits {
if len(desc) != 0 {
desc += "\n\n"
}
desc += fmt.Sprintf("<a href=\"%s\">%s</a>\n%s",
- html.EscapeString(fmt.Sprintf("%s/commit/%s", act.GetRepoAbsoluteLink(), commit.Sha1)),
+ html.EscapeString(fmt.Sprintf("%s/commit/%s", act.GetRepoAbsoluteLink(ctx), commit.Sha1)),
commit.Sha1,
templates.RenderCommitMessage(ctx, commit.Message, repoLink, nil),
)
if push.Len > 1 {
link = &feeds.Link{Href: fmt.Sprintf("%s/%s", setting.AppSubURL, push.CompareURL)}
} else if push.Len == 1 {
- link = &feeds.Link{Href: fmt.Sprintf("%s/commit/%s", act.GetRepoAbsoluteLink(), push.Commits[0].Sha1)}
+ link = &feeds.Link{Href: fmt.Sprintf("%s/commit/%s", act.GetRepoAbsoluteLink(ctx), push.Commits[0].Sha1)}
}
case activities_model.ActionCreateIssue, activities_model.ActionCreatePullRequest:
desc = strings.Join(act.GetIssueInfos(), "#")
content = renderMarkdown(ctx, act, act.GetIssueContent(ctx))
case activities_model.ActionCommentIssue, activities_model.ActionApprovePullRequest, activities_model.ActionRejectPullRequest, activities_model.ActionCommentPull:
- desc = act.GetIssueTitle()
+ desc = act.GetIssueTitle(ctx)
comment := act.GetIssueInfos()[1]
if len(comment) != 0 {
desc += "\n\n" + renderMarkdown(ctx, act, comment)
case activities_model.ActionMergePullRequest, activities_model.ActionAutoMergePullRequest:
desc = act.GetIssueInfos()[1]
case activities_model.ActionCloseIssue, activities_model.ActionReopenIssue, activities_model.ActionClosePullRequest, activities_model.ActionReopenPullRequest:
- desc = act.GetIssueTitle()
+ desc = act.GetIssueTitle(ctx)
case activities_model.ActionPullReviewDismissed:
desc = ctx.Tr("action.review_dismissed_reason") + "\n\n" + act.GetIssueInfos()[2]
}
newProject.Type = project_model.TypeIndividual
}
- if err := project_model.NewProject(&newProject); err != nil {
+ if err := project_model.NewProject(ctx, &newProject); err != nil {
ctx.ServerError("NewProject", err)
return
}
}
id := ctx.ParamsInt64(":id")
- if err := project_model.ChangeProjectStatusByRepoIDAndID(0, id, toClose); err != nil {
+ if err := project_model.ChangeProjectStatusByRepoIDAndID(ctx, 0, id, toClose); err != nil {
if project_model.IsErrProjectNotExist(err) {
ctx.NotFound("", err)
} else {
ctx.Flash.Success(ctx.Tr("repo.projects.edit_success", p.Title))
if ctx.FormString("redirect") == "project" {
- ctx.Redirect(p.Link())
+ ctx.Redirect(p.Link(ctx))
} else {
ctx.Redirect(ctx.ContextUser.HomeLink() + "/-/projects")
}
return
}
- if err := project_model.DeleteBoardByID(ctx.ParamsInt64(":boardID")); err != nil {
+ if err := project_model.DeleteBoardByID(ctx, ctx.ParamsInt64(":boardID")); err != nil {
ctx.ServerError("DeleteProjectBoardByID", err)
return
}
return
}
- if err := project_model.NewBoard(&project_model.Board{
+ if err := project_model.NewBoard(ctx, &project_model.Board{
ProjectID: project.ID,
Title: form.Title,
Color: form.Color,
return
}
- if err := project_model.SetDefaultBoard(project.ID, board.ID); err != nil {
+ if err := project_model.SetDefaultBoard(ctx, project.ID, board.ID); err != nil {
ctx.ServerError("SetDefaultBoard", err)
return
}
return
}
- if err := project_model.SetDefaultBoard(project.ID, 0); err != nil {
+ if err := project_model.SetDefaultBoard(ctx, project.ID, 0); err != nil {
ctx.ServerError("SetDefaultBoard", err)
return
}
}
}
- if err = project_model.MoveIssuesOnProjectBoard(board, sortedIssueIDs); err != nil {
+ if err = project_model.MoveIssuesOnProjectBoard(ctx, board, sortedIssueIDs); err != nil {
ctx.ServerError("MoveIssuesOnProjectBoard", err)
return
}
ctx.Data["DiffNotAvailable"] = diff.NumFiles == 0
if err := asymkey_model.CalculateTrustStatus(verification, ctx.Repo.Repository.GetTrustModel(), func(user *user_model.User) (bool, error) {
- return repo_model.IsOwnerMemberCollaborator(ctx.Repo.Repository, user.ID)
+ return repo_model.IsOwnerMemberCollaborator(ctx, ctx.Repo.Repository, user.ID)
}, nil); err != nil {
ctx.ServerError("CalculateTrustStatus", err)
return
marked[comment.PosterID] = comment.ShowRole
participants = addParticipant(comment.Poster, participants)
} else if comment.Type == issues_model.CommentTypeLabel {
- if err = comment.LoadLabel(); err != nil {
+ if err = comment.LoadLabel(ctx); err != nil {
ctx.ServerError("LoadLabel", err)
return
}
}
} else if comment.Type == issues_model.CommentTypeProject {
- if err = comment.LoadProject(); err != nil {
+ if err = comment.LoadProject(ctx); err != nil {
ctx.ServerError("LoadProject", err)
return
}
}
} else if comment.Type == issues_model.CommentTypeAssignees || comment.Type == issues_model.CommentTypeReviewRequest {
- if err = comment.LoadAssigneeUserAndTeam(); err != nil {
+ if err = comment.LoadAssigneeUserAndTeam(ctx); err != nil {
ctx.ServerError("LoadAssigneeUserAndTeam", err)
return
}
} else if comment.Type == issues_model.CommentTypeRemoveDependency || comment.Type == issues_model.CommentTypeAddDependency {
- if err = comment.LoadDepIssueDetails(); err != nil {
+ if err = comment.LoadDepIssueDetails(ctx); err != nil {
if !issues_model.IsErrIssueNotExist(err) {
ctx.ServerError("LoadDepIssueDetails", err)
return
ctx.ServerError("RenderString", err)
return
}
- if err = comment.LoadReview(); err != nil && !issues_model.IsErrReviewNotExist(err) {
+ if err = comment.LoadReview(ctx); err != nil && !issues_model.IsErrReviewNotExist(err) {
ctx.ServerError("LoadReview", err)
return
}
}
}
}
- if err = comment.LoadResolveDoer(); err != nil {
+ if err = comment.LoadResolveDoer(ctx); err != nil {
ctx.ServerError("LoadResolveDoer", err)
return
}
return
}
- if ctx.Data["CanMarkConversation"], err = issues_model.CanMarkConversation(issue, ctx.Doer); err != nil {
+ if ctx.Data["CanMarkConversation"], err = issues_model.CanMarkConversation(ctx, issue, ctx.Doer); err != nil {
ctx.ServerError("CanMarkConversation", err)
return
}
deadlineUnix = timeutil.TimeStamp(deadline.Unix())
}
- if err := issues_model.UpdateIssueDeadline(issue, deadlineUnix, ctx.Doer); err != nil {
+ if err := issues_model.UpdateIssueDeadline(ctx, issue, deadlineUnix, ctx.Doer); err != nil {
ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err.Error())
return
}
}
// Reload new reactions
comment.Reactions = nil
- if err = comment.LoadReactions(ctx.Repo.Repository); err != nil {
+ if err = comment.LoadReactions(ctx, ctx.Repo.Repository); err != nil {
log.Info("comment.LoadReactions: %s", err)
break
}
// Reload new reactions
comment.Reactions = nil
- if err = comment.LoadReactions(ctx.Repo.Repository); err != nil {
+ if err = comment.LoadReactions(ctx, ctx.Repo.Repository); err != nil {
log.Info("comment.LoadReactions: %s", err)
break
}
if len(files) > 0 {
switch content := item.(type) {
case *issues_model.Issue:
- err = issues_model.UpdateIssueAttachments(content.ID, files)
+ err = issues_model.UpdateIssueAttachments(ctx, content.ID, files)
case *issues_model.Comment:
- err = content.UpdateAttachments(files)
+ err = content.UpdateAttachments(ctx, files)
default:
return fmt.Errorf("unknown Type: %T", content)
}
return
}
- if err := project_model.NewProject(&project_model.Project{
+ if err := project_model.NewProject(ctx, &project_model.Project{
RepoID: ctx.Repo.Repository.ID,
Title: form.Title,
Description: form.Content,
}
id := ctx.ParamsInt64(":id")
- if err := project_model.ChangeProjectStatusByRepoIDAndID(ctx.Repo.Repository.ID, id, toClose); err != nil {
+ if err := project_model.ChangeProjectStatusByRepoIDAndID(ctx, ctx.Repo.Repository.ID, id, toClose); err != nil {
if project_model.IsErrProjectNotExist(err) {
ctx.NotFound("", err)
} else {
ctx.Flash.Success(ctx.Tr("repo.projects.edit_success", p.Title))
if ctx.FormString("redirect") == "project" {
- ctx.Redirect(p.Link())
+ ctx.Redirect(p.Link(ctx))
} else {
ctx.Redirect(ctx.Repo.RepoLink + "/projects")
}
return
}
- if err := project_model.DeleteBoardByID(ctx.ParamsInt64(":boardID")); err != nil {
+ if err := project_model.DeleteBoardByID(ctx, ctx.ParamsInt64(":boardID")); err != nil {
ctx.ServerError("DeleteProjectBoardByID", err)
return
}
return
}
- if err := project_model.NewBoard(&project_model.Board{
+ if err := project_model.NewBoard(ctx, &project_model.Board{
ProjectID: project.ID,
Title: form.Title,
Color: form.Color,
return
}
- if err := project_model.SetDefaultBoard(project.ID, board.ID); err != nil {
+ if err := project_model.SetDefaultBoard(ctx, project.ID, board.ID); err != nil {
ctx.ServerError("SetDefaultBoard", err)
return
}
return
}
- if err := project_model.SetDefaultBoard(project.ID, 0); err != nil {
+ if err := project_model.SetDefaultBoard(ctx, project.ID, 0); err != nil {
ctx.ServerError("SetDefaultBoard", err)
return
}
}
}
- if err = project_model.MoveIssuesOnProjectBoard(board, sortedIssueIDs); err != nil {
+ if err = project_model.MoveIssuesOnProjectBoard(ctx, board, sortedIssueIDs); err != nil {
ctx.ServerError("MoveIssuesOnProjectBoard", err)
return
}
}
if ctx.IsSigned && ctx.Doer != nil {
- if ctx.Data["CanMarkConversation"], err = issues_model.CanMarkConversation(issue, ctx.Doer); err != nil {
+ if ctx.Data["CanMarkConversation"], err = issues_model.CanMarkConversation(ctx, issue, ctx.Doer); err != nil {
ctx.ServerError("CanMarkConversation", err)
return
}
}
numPendingCodeComments := int64(0)
if currentReview != nil {
- numPendingCodeComments, err = issues_model.CountComments(&issues_model.FindCommentsOptions{
+ numPendingCodeComments, err = issues_model.CountComments(ctx, &issues_model.FindCommentsOptions{
Type: issues_model.CommentTypeCode,
ReviewID: currentReview.ID,
IssueID: issue.ID,
renderConversation(ctx, comment)
return
}
- ctx.Redirect(comment.Link())
+ ctx.Redirect(comment.Link(ctx))
}
// UpdateResolveConversation add or remove an Conversation resolved mark
}
var permResult bool
- if permResult, err = issues_model.CanMarkConversation(comment.Issue, ctx.Doer); err != nil {
+ if permResult, err = issues_model.CanMarkConversation(ctx, comment.Issue, ctx.Doer); err != nil {
ctx.ServerError("CanMarkConversation", err)
return
}
}
if action == "Resolve" || action == "UnResolve" {
- err = issues_model.MarkConversation(comment, ctx.Doer, action == "Resolve")
+ err = issues_model.MarkConversation(ctx, comment, ctx.Doer, action == "Resolve")
if err != nil {
ctx.ServerError("MarkConversation", err)
return
if _, err := repo_module.CleanUpMigrateInfo(ctx, repo); err != nil {
ctx.ServerError("CleanUpMigrateInfo", err)
return
- } else if err = repo_model.DeleteMirrorByRepoID(ctx.Repo.Repository.ID); err != nil {
+ } else if err = repo_model.DeleteMirrorByRepoID(ctx, ctx.Repo.Repository.ID); err != nil {
ctx.ServerError("DeleteMirrorByRepoID", err)
return
}
verification := asymkey_model.ParseCommitWithSignature(ctx, latestCommit)
if err := asymkey_model.CalculateTrustStatus(verification, ctx.Repo.Repository.GetTrustModel(), func(user *user_model.User) (bool, error) {
- return repo_model.IsOwnerMemberCollaborator(ctx.Repo.Repository, user.ID)
+ return repo_model.IsOwnerMemberCollaborator(ctx, ctx.Repo.Repository, user.ID)
}, nil); err != nil {
ctx.ServerError("CalculateTrustStatus", err)
return nil
return &api.Comment{
ID: c.ID,
Poster: ToUser(ctx, c.Poster, nil),
- HTMLURL: c.HTMLURL(),
- IssueURL: c.IssueURL(),
- PRURL: c.PRURL(),
+ HTMLURL: c.HTMLURL(ctx),
+ IssueURL: c.IssueURL(ctx),
+ PRURL: c.PRURL(ctx),
Body: c.Content,
Attachments: ToAPIAttachments(repo, c.Attachments),
Created: c.CreatedUnix.AsTime(),
return nil
}
- err = c.LoadAssigneeUserAndTeam()
+ err = c.LoadAssigneeUserAndTeam(ctx)
if err != nil {
log.Error("LoadAssigneeUserAndTeam: %v", err)
return nil
}
- err = c.LoadResolveDoer()
+ err = c.LoadResolveDoer(ctx)
if err != nil {
log.Error("LoadResolveDoer: %v", err)
return nil
}
- err = c.LoadDepIssueDetails()
+ err = c.LoadDepIssueDetails(ctx)
if err != nil {
log.Error("LoadDepIssueDetails: %v", err)
return nil
return nil
}
- err = c.LoadLabel()
+ err = c.LoadLabel(ctx)
if err != nil {
log.Error("LoadLabel: %v", err)
return nil
ID: c.ID,
Type: c.Type.String(),
Poster: ToUser(ctx, c.Poster, nil),
- HTMLURL: c.HTMLURL(),
- IssueURL: c.IssueURL(),
- PRURL: c.PRURL(),
+ HTMLURL: c.HTMLURL(ctx),
+ IssueURL: c.IssueURL(ctx),
+ PRURL: c.PRURL(ctx),
Body: c.Content,
Created: c.CreatedUnix.AsTime(),
Updated: c.UpdatedUnix.AsTime(),
package convert
import (
+ "context"
"net/url"
activities_model "code.gitea.io/gitea/models/activities"
- "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/models/perm"
access_model "code.gitea.io/gitea/models/perm/access"
api "code.gitea.io/gitea/modules/structs"
)
// ToNotificationThread convert a Notification to api.NotificationThread
-func ToNotificationThread(n *activities_model.Notification) *api.NotificationThread {
+func ToNotificationThread(ctx context.Context, n *activities_model.Notification) *api.NotificationThread {
result := &api.NotificationThread{
ID: n.ID,
Unread: !(n.Status == activities_model.NotificationStatusRead || n.Status == activities_model.NotificationStatusPinned),
// since user only get notifications when he has access to use minimal access mode
if n.Repository != nil {
- result.Repository = ToRepo(db.DefaultContext, n.Repository, access_model.Permission{AccessMode: perm.AccessModeRead})
+ result.Repository = ToRepo(ctx, n.Repository, access_model.Permission{AccessMode: perm.AccessModeRead})
// This permission is not correct and we should not be reporting it
for repository := result.Repository; repository != nil; repository = repository.Parent {
result.Subject.State = n.Issue.State()
comment, err := n.Issue.GetLastComment()
if err == nil && comment != nil {
- result.Subject.LatestCommentURL = comment.APIURL()
- result.Subject.LatestCommentHTMLURL = comment.HTMLURL()
+ result.Subject.LatestCommentURL = comment.APIURL(ctx)
+ result.Subject.LatestCommentHTMLURL = comment.HTMLURL(ctx)
}
}
case activities_model.NotificationSourcePullRequest:
result.Subject.State = n.Issue.State()
comment, err := n.Issue.GetLastComment()
if err == nil && comment != nil {
- result.Subject.LatestCommentURL = comment.APIURL()
- result.Subject.LatestCommentHTMLURL = comment.HTMLURL()
+ result.Subject.LatestCommentURL = comment.APIURL(ctx)
+ result.Subject.LatestCommentHTMLURL = comment.HTMLURL(ctx)
}
pr, _ := n.Issue.GetPullRequest()
}
// ToNotifications convert list of Notification to api.NotificationThread list
-func ToNotifications(nl activities_model.NotificationList) []*api.NotificationThread {
+func ToNotifications(ctx context.Context, nl activities_model.NotificationList) []*api.NotificationThread {
result := make([]*api.NotificationThread, 0, len(nl))
for _, n := range nl {
- result = append(result, ToNotificationThread(n))
+ result = append(result, ToNotificationThread(ctx, n))
}
return result
}
Stale: r.Stale,
Official: r.Official,
Dismissed: r.Dismissed,
- CodeCommentsCount: r.GetCodeCommentsCount(),
+ CodeCommentsCount: r.GetCodeCommentsCount(ctx),
Submitted: r.CreatedUnix.AsTime(),
Updated: r.UpdatedUnix.AsTime(),
- HTMLURL: r.HTMLURL(),
+ HTMLURL: r.HTMLURL(ctx),
HTMLPullURL: r.Issue.HTMLURL(),
}
CommitID: comment.CommitSHA,
OrigCommitID: comment.OldRef,
DiffHunk: patch2diff(comment.Patch),
- HTMLURL: comment.HTMLURL(),
+ HTMLURL: comment.HTMLURL(ctx),
HTMLPullURL: review.Issue.HTMLURL(),
}
OlderThan: 365 * 24 * time.Hour,
}, func(ctx context.Context, _ *user_model.User, config Config) error {
olderThanConfig := config.(*OlderThanConfig)
- return activities_model.DeleteOldActions(olderThanConfig.OlderThan)
+ return activities_model.DeleteOldActions(ctx, olderThanConfig.OlderThan)
})
}
// UpdateMigrationsByType updates all migrated repositories' posterid from gitServiceType to replace originalAuthorID to posterID
func UpdateMigrationsByType(ctx context.Context, tp structs.GitServiceType, externalUserID string, userID int64) error {
- if err := issues_model.UpdateIssuesMigrationsByType(tp, externalUserID, userID); err != nil {
+ if err := issues_model.UpdateIssuesMigrationsByType(ctx, tp, externalUserID, userID); err != nil {
return err
}
- if err := issues_model.UpdateCommentsMigrationsByType(tp, externalUserID, userID); err != nil {
+ if err := issues_model.UpdateCommentsMigrationsByType(ctx, tp, externalUserID, userID); err != nil {
return err
}
return err
}
- if err := issues_model.UpdateReactionsMigrationsByType(tp, externalUserID, userID); err != nil {
+ if err := issues_model.UpdateReactionsMigrationsByType(ctx, tp, externalUserID, userID); err != nil {
return err
}
- return issues_model.UpdateReviewsMigrationsByType(tp, externalUserID, userID)
+ return issues_model.UpdateReviewsMigrationsByType(ctx, tp, externalUserID, userID)
}
actions = append(actions, action)
}
- if err := activities_model.NotifyWatchersActions(actions); err != nil {
+ if err := activities_model.NotifyWatchersActions(ctx, actions); err != nil {
log.Error("notify watchers '%d/%d': %v", review.Reviewer.ID, review.Issue.RepoID, err)
}
}
}
}
- if err := issues_model.UpdateComment(c, doer); err != nil {
+ if err := issues_model.UpdateComment(ctx, c, doer); err != nil {
return err
}
func ChangeContent(ctx context.Context, issue *issues_model.Issue, doer *user_model.User, content string) (err error) {
oldContent := issue.Content
- if err := issues_model.ChangeIssueContent(issue, doer, content); err != nil {
+ if err := issues_model.ChangeIssueContent(ctx, issue, doer, content); err != nil {
return err
}
// NewIssue creates new issue with labels for repository.
func NewIssue(ctx context.Context, repo *repo_model.Repository, issue *issues_model.Issue, labelIDs []int64, uuids []string, assigneeIDs []int64) error {
- if err := issues_model.NewIssue(repo, issue, labelIDs, uuids); err != nil {
+ if err := issues_model.NewIssue(ctx, repo, issue, labelIDs, uuids); err != nil {
return err
}
oldRef := issue.Ref
issue.Ref = ref
- if err := issues_model.ChangeIssueRef(issue, doer, oldRef); err != nil {
+ if err := issues_model.ChangeIssueRef(ctx, issue, doer, oldRef); err != nil {
return err
}
if len(cms) == 0 {
return nil
}
- return issues_model.InsertIssueComments(cms)
+ return issues_model.InsertIssueComments(g.ctx, cms)
}
// CreatePullRequests creates pull requests
}
}
- return issues_model.InsertReviews(cms)
+ return issues_model.InsertReviews(g.ctx, cms)
}
// Rollback when migrating failed, this will rollback all the changes.
var referenceID int64
if m, ok := bean.(*repo_model.Mirror); ok {
- if m.GetRepository() == nil {
+ if m.GetRepository(ctx) == nil {
log.Error("Disconnected mirror found: %d", m.ID)
return nil
}
pullMirrorsRequested := 0
if pullLimit != 0 {
- if err := repo_model.MirrorsIterate(pullLimit, func(idx int, bean any) error {
+ if err := repo_model.MirrorsIterate(ctx, pullLimit, func(idx int, bean any) error {
if err := handler(idx, bean); err != nil {
return err
}
// UpdateAddress writes new address to Git repository and database
func UpdateAddress(ctx context.Context, m *repo_model.Mirror, addr string) error {
remoteName := m.GetRemoteName()
- repoPath := m.GetRepository().RepoPath()
+ repoPath := m.GetRepository(ctx).RepoPath()
// Remove old remote
_, _, err := git.NewCommand(ctx, "remote", "rm").AddDynamicArguments(remoteName).RunStdString(&git.RunOpts{Dir: repoPath})
if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
log.Error("SyncMirrors [repo_id: %v]: unable to GetMirrorByRepoID: %v", repoID, err)
return false
}
- _ = m.GetRepository() // force load repository of mirror
+ _ = m.GetRepository(ctx) // force load repository of mirror
ctx, _, finished := process.GetManager().AddContext(ctx, fmt.Sprintf("Syncing Mirror %s/%s", m.Repo.OwnerName, m.Repo.Name))
defer finished()
}
if changed {
// Mark old reviews as stale if diff to mergebase has changed
- if err := issues_model.MarkReviewsAsStale(pr.IssueID); err != nil {
+ if err := issues_model.MarkReviewsAsStale(ctx, pr.IssueID); err != nil {
log.Error("MarkReviewsAsStale: %v", err)
}
}
}
}
- if err := issues_model.MarkReviewsAsNotStale(pr.IssueID, newCommitID); err != nil {
+ if err := issues_model.MarkReviewsAsNotStale(ctx, pr.IssueID, newCommitID); err != nil {
log.Error("MarkReviewsAsNotStale: %v", err)
}
divergence, err := GetDiverging(ctx, pr)
if !pendingReview && replyReviewID != 0 {
// It's not part of a review; maybe a reply to a review comment or a single comment.
// Check if there are reviews for that line already; if there are, this is a reply
- if existsReview, err = issues_model.ReviewExists(issue, treePath, line); err != nil {
+ if existsReview, err = issues_model.ReviewExists(ctx, issue, treePath, line); err != nil {
return nil, err
}
}
}
}
- review, comm, err := issues_model.SubmitReview(doer, issue, reviewType, content, commitID, stale, attachmentUUIDs)
+ review, comm, err := issues_model.SubmitReview(ctx, doer, issue, reviewType, content, commitID, stale, attachmentUUIDs)
if err != nil {
return nil, nil, err
}
func handler(items ...issueNotificationOpts) []issueNotificationOpts {
for _, opts := range items {
- if err := activities_model.CreateOrUpdateIssueNotifications(opts.IssueID, opts.CommentID, opts.NotificationAuthorID, opts.ReceiverID); err != nil {
+ if err := activities_model.CreateOrUpdateIssueNotifications(db.DefaultContext, opts.IssueID, opts.CommentID, opts.NotificationAuthorID, opts.ReceiverID); err != nil {
log.Error("Was unable to create issue notification: %v", err)
}
}
<li class="milestone-card">
<h3 class="flex-text-block gt-m-0">
{{svg .IconName 16}}
- <a class="muted" href="{{.Link}}">{{.Title}}</a>
+ <a class="muted" href="{{.Link ctx}}">{{.Title}}</a>
</h3>
<div class="milestone-toolbar">
<div class="group">
<div class="flex-text-block">
{{svg "octicon-issue-opened" 14}}
- {{ctx.Locale.PrettyNumber .NumOpenIssues}} {{ctx.Locale.Tr "repo.issues.open_title"}}
+ {{ctx.Locale.PrettyNumber (.NumOpenIssues ctx)}} {{ctx.Locale.Tr "repo.issues.open_title"}}
</div>
<div class="flex-text-block">
{{svg "octicon-check" 14}}
- {{ctx.Locale.PrettyNumber .NumClosedIssues}} {{ctx.Locale.Tr "repo.issues.closed_title"}}
+ {{ctx.Locale.PrettyNumber (.NumClosedIssues ctx)}} {{ctx.Locale.Tr "repo.issues.closed_title"}}
</div>
</div>
{{if and $.CanWriteProjects (not $.Repository.IsArchived)}}
<div class="group">
- <a class="flex-text-inline" href="{{.Link}}/edit">{{svg "octicon-pencil" 14}}{{ctx.Locale.Tr "repo.issues.label_edit"}}</a>
+ <a class="flex-text-inline" href="{{.Link ctx}}/edit">{{svg "octicon-pencil" 14}}{{ctx.Locale.Tr "repo.issues.label_edit"}}</a>
{{if .IsClosed}}
- <a class="link-action flex-text-inline" href data-url="{{.Link}}/open">{{svg "octicon-check" 14}}{{ctx.Locale.Tr "repo.projects.open"}}</a>
+ <a class="link-action flex-text-inline" href data-url="{{.Link ctx}}/open">{{svg "octicon-check" 14}}{{ctx.Locale.Tr "repo.projects.open"}}</a>
{{else}}
- <a class="link-action flex-text-inline" href data-url="{{.Link}}/close">{{svg "octicon-skip" 14}}{{ctx.Locale.Tr "repo.projects.close"}}</a>
+ <a class="link-action flex-text-inline" href data-url="{{.Link ctx}}/close">{{svg "octicon-skip" 14}}{{ctx.Locale.Tr "repo.projects.close"}}</a>
{{end}}
- <a class="delete-button flex-text-inline" href="#" data-url="{{.Link}}/delete">{{svg "octicon-trash" 14}}{{ctx.Locale.Tr "repo.issues.label_delete"}}</a>
+ <a class="delete-button flex-text-inline" href="#" data-url="{{.Link ctx}}/delete">{{svg "octicon-trash" 14}}{{ctx.Locale.Tr "repo.issues.label_delete"}}</a>
</div>
{{end}}
</div>
<div class="project-column-header">
<div class="ui large label project-column-title gt-py-2">
<div class="ui small circular grey label project-column-issue-count">
- {{.NumIssues}}
+ {{.NumIssues ctx}}
</div>
{{.Title}}
</div>
</a>
{{range .Actors}}
<a class="item{{if eq .ID $.CurActor}} active{{end}}" href="{{$.Link}}?workflow={{$.CurWorkflow}}&actor={{.ID}}&status={{$.CurStatus}}">
- {{ctx.AvatarUtils.Avatar . 20}} {{.GetDisplayName}}
+ {{ctx.AvatarUtils.Avatar . 20}} {{.GetDisplayName ctx}}
</a>
{{end}}
</div>
{{if eq .RefAction 3}}<del>{{end}}
<span class="text grey muted-links">
{{template "shared/user/authorlink" .Poster}}
- {{ctx.Locale.Tr $refTr (.EventTag|Escape) $createdStr (.RefCommentLink|Escape) $refFrom | Safe}}
+ {{ctx.Locale.Tr $refTr (.EventTag|Escape) $createdStr ((.RefCommentLink ctx)|Escape) $refFrom | Safe}}
</span>
{{if eq .RefAction 3}}</del>{{end}}
<div class="detail">
- <span class="text grey muted-links"><a href="{{.RefIssueLink}}"><b>{{.RefIssueTitle}}</b> {{.RefIssueIdent}}</a></span>
+ <span class="text grey muted-links"><a href="{{.RefIssueLink ctx}}"><b>{{.RefIssueTitle ctx}}</b> {{.RefIssueIdent ctx}}</a></span>
</div>
</div>
{{else if eq .Type 4}}
{{$resolveDoer := (index $comms 0).ResolveDoer}}
{{$isNotPending := (not (eq (index $comms 0).Review.Type 0))}}
<div class="gt-df gt-ac">
- <a href="{{(index $comms 0).CodeCommentLink}}" class="file-comment gt-ml-3 gt-word-break">{{$filename}}</a>
+ <a href="{{(index $comms 0).CodeCommentLink ctx}}" class="file-comment gt-ml-3 gt-word-break">{{$filename}}</a>
{{if $invalid}}
<span class="ui label basic small gt-ml-3" data-tooltip-content="{{ctx.Locale.Tr "repo.issues.review.outdated_description"}}">
{{ctx.Locale.Tr "repo.issues.review.outdated"}}
{{ctx.Locale.Tr "repo.issues.new.open_projects"}}
</div>
{{range .OpenProjects}}
- <a class="item muted sidebar-item-link" data-id="{{.ID}}" data-href="{{.Link}}">
+ <a class="item muted sidebar-item-link" data-id="{{.ID}}" data-href="{{.Link ctx}}">
{{svg .IconName 18 "gt-mr-3"}}{{.Title}}
</a>
{{end}}
{{ctx.Locale.Tr "repo.issues.new.closed_projects"}}
</div>
{{range .ClosedProjects}}
- <a class="item muted sidebar-item-link" data-id="{{.ID}}" data-href="{{.Link}}">
+ <a class="item muted sidebar-item-link" data-id="{{.ID}}" data-href="{{.Link ctx}}">
{{svg .IconName 18 "gt-mr-3"}}{{.Title}}
</a>
{{end}}
<span class="no-select item {{if .Issue.Project}}gt-hidden{{end}}">{{ctx.Locale.Tr "repo.issues.new.no_projects"}}</span>
<div class="selected">
{{if .Issue.Project}}
- <a class="item muted sidebar-item-link" href="{{.Issue.Project.Link}}">
+ <a class="item muted sidebar-item-link" href="{{.Issue.Project.Link ctx}}">
{{svg .Issue.Project.IconName 18 "gt-mr-3"}}{{.Issue.Project.Title}}
</a>
{{end}}
</a>
{{end}}
{{if .Project}}
- <a class="project flex-text-inline" href="{{.Project.Link}}">
+ <a class="project flex-text-inline" href="{{.Project.Link ctx}}">
{{svg .Project.IconName 14}}{{.Project.Title}}
</a>
{{end}}
<div class="flex-item-main gt-gap-3">
<div>
{{if gt .ActUser.ID 0}}
- <a href="{{AppSubUrl}}/{{.GetActUserName | PathEscape}}" title="{{.GetDisplayNameTitle}}">{{.GetDisplayName}}</a>
+ <a href="{{AppSubUrl}}/{{(.GetActUserName ctx) | PathEscape}}" title="{{.GetDisplayNameTitle ctx}}">{{.GetDisplayName ctx}}</a>
{{else}}
- {{.ShortActUserName}}
+ {{.ShortActUserName ctx}}
{{end}}
{{if .GetOpType.InActions "create_repo"}}
- {{ctx.Locale.Tr "action.create_repo" (.GetRepoLink|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.create_repo" ((.GetRepoLink ctx)|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "rename_repo"}}
- {{ctx.Locale.Tr "action.rename_repo" (.GetContent|Escape) (.GetRepoLink|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.rename_repo" (.GetContent|Escape) ((.GetRepoLink ctx)|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "commit_repo"}}
{{if .Content}}
- {{ctx.Locale.Tr "action.commit_repo" (.GetRepoLink|Escape) (.GetRefLink|Escape) (Escape .GetBranch) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.commit_repo" ((.GetRepoLink ctx)|Escape) ((.GetRefLink ctx)|Escape) (Escape .GetBranch) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else}}
- {{ctx.Locale.Tr "action.create_branch" (.GetRepoLink|Escape) (.GetRefLink|Escape) (Escape .GetBranch) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.create_branch" ((.GetRepoLink ctx)|Escape) ((.GetRefLink ctx)|Escape) (Escape .GetBranch) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{end}}
{{else if .GetOpType.InActions "create_issue"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.create_issue" ((printf "%s/issues/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.create_issue" ((printf "%s/issues/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "create_pull_request"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.create_pull_request" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.create_pull_request" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "transfer_repo"}}
- {{ctx.Locale.Tr "action.transfer_repo" .GetContent (.GetRepoLink|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.transfer_repo" .GetContent ((.GetRepoLink ctx)|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "push_tag"}}
- {{ctx.Locale.Tr "action.push_tag" (.GetRepoLink|Escape) (.GetRefLink|Escape) (.GetTag|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.push_tag" ((.GetRepoLink ctx)|Escape) ((.GetRefLink ctx)|Escape) (.GetTag|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "comment_issue"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.comment_issue" ((printf "%s/issues/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.comment_issue" ((printf "%s/issues/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "merge_pull_request"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.merge_pull_request" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.merge_pull_request" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "close_issue"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.close_issue" ((printf "%s/issues/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.close_issue" ((printf "%s/issues/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "reopen_issue"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.reopen_issue" ((printf "%s/issues/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.reopen_issue" ((printf "%s/issues/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "close_pull_request"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.close_pull_request" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.close_pull_request" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "reopen_pull_request"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.reopen_pull_request" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.reopen_pull_request" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "delete_tag"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.delete_tag" (.GetRepoLink|Escape) (.GetTag|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.delete_tag" ((.GetRepoLink ctx)|Escape) (.GetTag|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "delete_branch"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.delete_branch" (.GetRepoLink|Escape) (.GetBranch|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.delete_branch" ((.GetRepoLink ctx)|Escape) (.GetBranch|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "mirror_sync_push"}}
- {{ctx.Locale.Tr "action.mirror_sync_push" (.GetRepoLink|Escape) (.GetRefLink|Escape) (.GetBranch|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.mirror_sync_push" ((.GetRepoLink ctx)|Escape) ((.GetRefLink ctx)|Escape) (.GetBranch|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "mirror_sync_create"}}
- {{ctx.Locale.Tr "action.mirror_sync_create" (.GetRepoLink|Escape) (.GetRefLink|Escape) (.GetBranch|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.mirror_sync_create" ((.GetRepoLink ctx)|Escape) ((.GetRefLink ctx)|Escape) (.GetBranch|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "mirror_sync_delete"}}
- {{ctx.Locale.Tr "action.mirror_sync_delete" (.GetRepoLink|Escape) (.GetBranch|Escape) (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.mirror_sync_delete" ((.GetRepoLink ctx)|Escape) (.GetBranch|Escape) ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "approve_pull_request"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.approve_pull_request" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.approve_pull_request" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "reject_pull_request"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.reject_pull_request" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.reject_pull_request" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "comment_pull"}}
{{$index := index .GetIssueInfos 0}}
- {{ctx.Locale.Tr "action.comment_pull" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) | Str2html}}
+ {{ctx.Locale.Tr "action.comment_pull" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) | Str2html}}
{{else if .GetOpType.InActions "publish_release"}}
{{$linkText := .Content | RenderEmoji $.Context}}
- {{ctx.Locale.Tr "action.publish_release" (.GetRepoLink|Escape) ((printf "%s/releases/tag/%s" .GetRepoLink .GetTag)|Escape) (.ShortRepoPath|Escape) $linkText | Str2html}}
+ {{ctx.Locale.Tr "action.publish_release" ((.GetRepoLink ctx)|Escape) ((printf "%s/releases/tag/%s" .GetRepoLink .GetTag)|Escape) ((.ShortRepoPath ctx)|Escape) $linkText | Str2html}}
{{else if .GetOpType.InActions "review_dismissed"}}
{{$index := index .GetIssueInfos 0}}
{{$reviewer := index .GetIssueInfos 1}}
- {{ctx.Locale.Tr "action.review_dismissed" ((printf "%s/pulls/%s" .GetRepoLink $index) |Escape) $index (.ShortRepoPath|Escape) $reviewer | Str2html}}
+ {{ctx.Locale.Tr "action.review_dismissed" ((printf "%s/pulls/%s" (.GetRepoLink ctx) $index) |Escape) $index ((.ShortRepoPath ctx)|Escape) $reviewer | Str2html}}
{{end}}
</div>
{{if .GetOpType.InActions "commit_repo" "mirror_sync_push"}}
{{$push := ActionContent2Commits .}}
- {{$repoLink := .GetRepoLink}}
+ {{$repoLink := (.GetRepoLink ctx)}}
{{range $push.Commits}}
{{$commitLink := printf "%s/commit/%s" $repoLink .Sha1}}
<div class="flex-text-block">
{{else if .GetOpType.InActions "create_pull_request"}}
<span class="text truncate issue title">{{index .GetIssueInfos 1 | RenderEmoji $.Context | RenderCodeBlock}}</span>
{{else if .GetOpType.InActions "comment_issue" "approve_pull_request" "reject_pull_request" "comment_pull"}}
- <a href="{{.GetCommentLink}}" class="text truncate issue title">{{.GetIssueTitle | RenderEmoji $.Context | RenderCodeBlock}}</a>
+ <a href="{{.GetCommentLink ctx}}" class="text truncate issue title">{{(.GetIssueTitle ctx) | RenderEmoji $.Context | RenderCodeBlock}}</a>
{{$comment := index .GetIssueInfos 1}}
{{if gt (len $comment) 0}}
<div class="flex-item-body">{{$comment | RenderEmoji $.Context | RenderCodeBlock}}</div>
{{else if .GetOpType.InActions "merge_pull_request"}}
<div class="flex-item-body">{{index .GetIssueInfos 1}}</div>
{{else if .GetOpType.InActions "close_issue" "reopen_issue" "close_pull_request" "reopen_pull_request"}}
- <span class="text truncate issue title">{{.GetIssueTitle | RenderEmoji $.Context | RenderCodeBlock}}</span>
+ <span class="text truncate issue title">{{(.GetIssueTitle ctx) | RenderEmoji $.Context | RenderCodeBlock}}</span>
{{else if .GetOpType.InActions "pull_review_dismissed"}}
<div class="flex-item-body">{{ctx.Locale.Tr "action.review_dismissed_reason"}}</div>
<div class="flex-item-body">{{index .GetIssueInfos 2 | RenderEmoji $.Context}}</div>
{{svg "octicon-repo" 16 "text grey"}}
{{end}}
</div>
- <a class="notifications-link gt-df gt-f1 gt-fc silenced" href="{{.Link}}">
+ <a class="notifications-link gt-df gt-f1 gt-fc silenced" href="{{.Link ctx}}">
<div class="notifications-top-row gt-font-13">
{{.Repository.FullName}} {{if .Issue}}<span class="text light-3">#{{.Issue.Index}}</span>{{end}}
{{if eq .Status 3}}
assert.EqualValues(t, "a review from a deleted user", reviewComments[0].Body)
assert.EqualValues(t, comment.ID, reviewComments[0].ID)
assert.EqualValues(t, comment.UpdatedUnix, reviewComments[0].Updated.Unix())
- assert.EqualValues(t, comment.HTMLURL(), reviewComments[0].HTMLURL)
+ assert.EqualValues(t, comment.HTMLURL(db.DefaultContext), reviewComments[0].HTMLURL)
// test CreatePullReview
req = NewRequestWithJSON(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/reviews?token=%s", repo.OwnerName, repo.Name, pullIssue.Index, token), &api.CreatePullReviewOptions{
projects / gitea.git / commitdiff