To avoid deadlock problem, almost database related functions should be have ctx as the first parameter. This PR do a refactor for some of these functions.tags/v1.21.0-rc0
@@ -391,10 +391,10 @@ func (a *Action) GetIssueInfos() []string { | |||
} | |||
// GetIssueTitle returns the title of first issue associated | |||
// with the action. | |||
// with the action. This function will be invoked in template so keep db.DefaultContext here | |||
func (a *Action) GetIssueTitle() string { | |||
index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64) | |||
issue, err := issues_model.GetIssueByIndex(a.RepoID, index) | |||
issue, err := issues_model.GetIssueByIndex(db.DefaultContext, a.RepoID, index) | |||
if err != nil { | |||
log.Error("GetIssueByIndex: %v", err) | |||
return "500 when get issue" | |||
@@ -404,9 +404,9 @@ func (a *Action) GetIssueTitle() string { | |||
// GetIssueContent returns the content of first issue associated with | |||
// this action. | |||
func (a *Action) GetIssueContent() string { | |||
func (a *Action) GetIssueContent(ctx context.Context) string { | |||
index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64) | |||
issue, err := issues_model.GetIssueByIndex(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" |
@@ -47,21 +47,21 @@ type ActivityStats struct { | |||
func GetActivityStats(ctx context.Context, repo *repo_model.Repository, timeFrom time.Time, releases, issues, prs, code bool) (*ActivityStats, error) { | |||
stats := &ActivityStats{Code: &git.CodeActivityStats{}} | |||
if releases { | |||
if err := stats.FillReleases(repo.ID, timeFrom); err != nil { | |||
if err := stats.FillReleases(ctx, repo.ID, timeFrom); err != nil { | |||
return nil, fmt.Errorf("FillReleases: %w", err) | |||
} | |||
} | |||
if prs { | |||
if err := stats.FillPullRequests(repo.ID, timeFrom); err != nil { | |||
if err := stats.FillPullRequests(ctx, repo.ID, timeFrom); err != nil { | |||
return nil, fmt.Errorf("FillPullRequests: %w", err) | |||
} | |||
} | |||
if issues { | |||
if err := stats.FillIssues(repo.ID, timeFrom); err != nil { | |||
if err := stats.FillIssues(ctx, repo.ID, timeFrom); err != nil { | |||
return nil, fmt.Errorf("FillIssues: %w", err) | |||
} | |||
} | |||
if err := stats.FillUnresolvedIssues(repo.ID, timeFrom, issues, prs); err != nil { | |||
if err := stats.FillUnresolvedIssues(ctx, repo.ID, timeFrom, issues, prs); err != nil { | |||
return nil, fmt.Errorf("FillUnresolvedIssues: %w", err) | |||
} | |||
if code { | |||
@@ -205,41 +205,41 @@ func (stats *ActivityStats) PublishedReleaseCount() int { | |||
} | |||
// FillPullRequests returns pull request information for activity page | |||
func (stats *ActivityStats) FillPullRequests(repoID int64, fromTime time.Time) error { | |||
func (stats *ActivityStats) FillPullRequests(ctx context.Context, repoID int64, fromTime time.Time) error { | |||
var err error | |||
var count int64 | |||
// Merged pull requests | |||
sess := pullRequestsForActivityStatement(repoID, fromTime, true) | |||
sess := pullRequestsForActivityStatement(ctx, repoID, fromTime, true) | |||
sess.OrderBy("pull_request.merged_unix DESC") | |||
stats.MergedPRs = make(issues_model.PullRequestList, 0) | |||
if err = sess.Find(&stats.MergedPRs); err != nil { | |||
return err | |||
} | |||
if err = stats.MergedPRs.LoadAttributes(); err != nil { | |||
if err = stats.MergedPRs.LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
// Merged pull request authors | |||
sess = pullRequestsForActivityStatement(repoID, fromTime, true) | |||
sess = pullRequestsForActivityStatement(ctx, repoID, fromTime, true) | |||
if _, err = sess.Select("count(distinct issue.poster_id) as `count`").Table("pull_request").Get(&count); err != nil { | |||
return err | |||
} | |||
stats.MergedPRAuthorCount = count | |||
// Opened pull requests | |||
sess = pullRequestsForActivityStatement(repoID, fromTime, false) | |||
sess = pullRequestsForActivityStatement(ctx, repoID, fromTime, false) | |||
sess.OrderBy("issue.created_unix ASC") | |||
stats.OpenedPRs = make(issues_model.PullRequestList, 0) | |||
if err = sess.Find(&stats.OpenedPRs); err != nil { | |||
return err | |||
} | |||
if err = stats.OpenedPRs.LoadAttributes(); err != nil { | |||
if err = stats.OpenedPRs.LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
// Opened pull request authors | |||
sess = pullRequestsForActivityStatement(repoID, fromTime, false) | |||
sess = pullRequestsForActivityStatement(ctx, repoID, fromTime, false) | |||
if _, err = sess.Select("count(distinct issue.poster_id) as `count`").Table("pull_request").Get(&count); err != nil { | |||
return err | |||
} | |||
@@ -248,8 +248,8 @@ func (stats *ActivityStats) FillPullRequests(repoID int64, fromTime time.Time) e | |||
return nil | |||
} | |||
func pullRequestsForActivityStatement(repoID int64, fromTime time.Time, merged bool) *xorm.Session { | |||
sess := db.GetEngine(db.DefaultContext).Where("pull_request.base_repo_id=?", repoID). | |||
func pullRequestsForActivityStatement(ctx context.Context, repoID int64, fromTime time.Time, merged bool) *xorm.Session { | |||
sess := db.GetEngine(ctx).Where("pull_request.base_repo_id=?", repoID). | |||
Join("INNER", "issue", "pull_request.issue_id = issue.id") | |||
if merged { | |||
@@ -264,12 +264,12 @@ func pullRequestsForActivityStatement(repoID int64, fromTime time.Time, merged b | |||
} | |||
// FillIssues returns issue information for activity page | |||
func (stats *ActivityStats) FillIssues(repoID int64, fromTime time.Time) error { | |||
func (stats *ActivityStats) FillIssues(ctx context.Context, repoID int64, fromTime time.Time) error { | |||
var err error | |||
var count int64 | |||
// Closed issues | |||
sess := issuesForActivityStatement(repoID, fromTime, true, false) | |||
sess := issuesForActivityStatement(ctx, repoID, fromTime, true, false) | |||
sess.OrderBy("issue.closed_unix DESC") | |||
stats.ClosedIssues = make(issues_model.IssueList, 0) | |||
if err = sess.Find(&stats.ClosedIssues); err != nil { | |||
@@ -277,14 +277,14 @@ func (stats *ActivityStats) FillIssues(repoID int64, fromTime time.Time) error { | |||
} | |||
// Closed issue authors | |||
sess = issuesForActivityStatement(repoID, fromTime, true, false) | |||
sess = issuesForActivityStatement(ctx, repoID, fromTime, true, false) | |||
if _, err = sess.Select("count(distinct issue.poster_id) as `count`").Table("issue").Get(&count); err != nil { | |||
return err | |||
} | |||
stats.ClosedIssueAuthorCount = count | |||
// New issues | |||
sess = issuesForActivityStatement(repoID, fromTime, false, false) | |||
sess = issuesForActivityStatement(ctx, repoID, fromTime, false, false) | |||
sess.OrderBy("issue.created_unix ASC") | |||
stats.OpenedIssues = make(issues_model.IssueList, 0) | |||
if err = sess.Find(&stats.OpenedIssues); err != nil { | |||
@@ -292,7 +292,7 @@ func (stats *ActivityStats) FillIssues(repoID int64, fromTime time.Time) error { | |||
} | |||
// Opened issue authors | |||
sess = issuesForActivityStatement(repoID, fromTime, false, false) | |||
sess = issuesForActivityStatement(ctx, repoID, fromTime, false, false) | |||
if _, err = sess.Select("count(distinct issue.poster_id) as `count`").Table("issue").Get(&count); err != nil { | |||
return err | |||
} | |||
@@ -302,12 +302,12 @@ func (stats *ActivityStats) FillIssues(repoID int64, fromTime time.Time) error { | |||
} | |||
// FillUnresolvedIssues returns unresolved issue and pull request information for activity page | |||
func (stats *ActivityStats) FillUnresolvedIssues(repoID int64, fromTime time.Time, issues, prs bool) error { | |||
func (stats *ActivityStats) FillUnresolvedIssues(ctx context.Context, repoID int64, fromTime time.Time, issues, prs bool) error { | |||
// Check if we need to select anything | |||
if !issues && !prs { | |||
return nil | |||
} | |||
sess := issuesForActivityStatement(repoID, fromTime, false, true) | |||
sess := issuesForActivityStatement(ctx, repoID, fromTime, false, true) | |||
if !issues || !prs { | |||
sess.And("issue.is_pull = ?", prs) | |||
} | |||
@@ -316,8 +316,8 @@ func (stats *ActivityStats) FillUnresolvedIssues(repoID int64, fromTime time.Tim | |||
return sess.Find(&stats.UnresolvedIssues) | |||
} | |||
func issuesForActivityStatement(repoID int64, fromTime time.Time, closed, unresolved bool) *xorm.Session { | |||
sess := db.GetEngine(db.DefaultContext).Where("issue.repo_id = ?", repoID). | |||
func issuesForActivityStatement(ctx context.Context, repoID int64, fromTime time.Time, closed, unresolved bool) *xorm.Session { | |||
sess := db.GetEngine(ctx).Where("issue.repo_id = ?", repoID). | |||
And("issue.is_closed = ?", closed) | |||
if !unresolved { | |||
@@ -336,12 +336,12 @@ func issuesForActivityStatement(repoID int64, fromTime time.Time, closed, unreso | |||
} | |||
// FillReleases returns release information for activity page | |||
func (stats *ActivityStats) FillReleases(repoID int64, fromTime time.Time) error { | |||
func (stats *ActivityStats) FillReleases(ctx context.Context, repoID int64, fromTime time.Time) error { | |||
var err error | |||
var count int64 | |||
// Published releases list | |||
sess := releasesForActivityStatement(repoID, fromTime) | |||
sess := releasesForActivityStatement(ctx, repoID, fromTime) | |||
sess.OrderBy("release.created_unix DESC") | |||
stats.PublishedReleases = make([]*repo_model.Release, 0) | |||
if err = sess.Find(&stats.PublishedReleases); err != nil { | |||
@@ -349,7 +349,7 @@ func (stats *ActivityStats) FillReleases(repoID int64, fromTime time.Time) error | |||
} | |||
// Published releases authors | |||
sess = releasesForActivityStatement(repoID, fromTime) | |||
sess = releasesForActivityStatement(ctx, repoID, fromTime) | |||
if _, err = sess.Select("count(distinct release.publisher_id) as `count`").Table("release").Get(&count); err != nil { | |||
return err | |||
} | |||
@@ -358,8 +358,8 @@ func (stats *ActivityStats) FillReleases(repoID int64, fromTime time.Time) error | |||
return nil | |||
} | |||
func releasesForActivityStatement(repoID int64, fromTime time.Time) *xorm.Session { | |||
return db.GetEngine(db.DefaultContext).Where("release.repo_id = ?", repoID). | |||
func releasesForActivityStatement(ctx context.Context, repoID int64, fromTime time.Time) *xorm.Session { | |||
return db.GetEngine(ctx).Where("release.repo_id = ?", repoID). | |||
And("release.is_draft = ?", false). | |||
And("release.created_unix >= ?", fromTime.Unix()) | |||
} |
@@ -465,8 +465,9 @@ func (comments CommentList) loadReviews(ctx context.Context) error { | |||
return nil | |||
} | |||
// loadAttributes loads all attributes | |||
func (comments CommentList) loadAttributes(ctx context.Context) (err error) { | |||
// LoadAttributes loads attributes of the comments, except for attachments and | |||
// comments | |||
func (comments CommentList) LoadAttributes(ctx context.Context) (err error) { | |||
if err = comments.LoadPosters(ctx); err != nil { | |||
return err | |||
} | |||
@@ -501,9 +502,3 @@ func (comments CommentList) loadAttributes(ctx context.Context) (err error) { | |||
return comments.loadDependentIssues(ctx) | |||
} | |||
// LoadAttributes loads attributes of the comments, except for attachments and | |||
// comments | |||
func (comments CommentList) LoadAttributes() error { | |||
return comments.loadAttributes(db.DefaultContext) | |||
} |
@@ -354,7 +354,7 @@ func (issue *Issue) LoadAttributes(ctx context.Context) (err error) { | |||
return err | |||
} | |||
if err = issue.Comments.loadAttributes(ctx); err != nil { | |||
if err = issue.Comments.LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
if issue.IsTimetrackerEnabled(ctx) { | |||
@@ -502,7 +502,7 @@ func (issue *Issue) GetLastEventLabelFake() string { | |||
} | |||
// GetIssueByIndex returns raw issue without loading attributes by index in a repository. | |||
func GetIssueByIndex(repoID, index int64) (*Issue, error) { | |||
func GetIssueByIndex(ctx context.Context, repoID, index int64) (*Issue, error) { | |||
if index < 1 { | |||
return nil, ErrIssueNotExist{} | |||
} | |||
@@ -510,7 +510,7 @@ func GetIssueByIndex(repoID, index int64) (*Issue, error) { | |||
RepoID: repoID, | |||
Index: index, | |||
} | |||
has, err := db.GetEngine(db.DefaultContext).Get(issue) | |||
has, err := db.GetEngine(ctx).Get(issue) | |||
if err != nil { | |||
return nil, err | |||
} else if !has { | |||
@@ -520,12 +520,12 @@ func GetIssueByIndex(repoID, index int64) (*Issue, error) { | |||
} | |||
// GetIssueWithAttrsByIndex returns issue by index in a repository. | |||
func GetIssueWithAttrsByIndex(repoID, index int64) (*Issue, error) { | |||
issue, err := GetIssueByIndex(repoID, index) | |||
func GetIssueWithAttrsByIndex(ctx context.Context, repoID, index int64) (*Issue, error) { | |||
issue, err := GetIssueByIndex(ctx, repoID, index) | |||
if err != nil { | |||
return nil, err | |||
} | |||
return issue, issue.LoadAttributes(db.DefaultContext) | |||
return issue, issue.LoadAttributes(ctx) | |||
} | |||
// GetIssueByID returns an issue by given ID. | |||
@@ -846,7 +846,7 @@ func GetPinnedIssues(ctx context.Context, repoID int64, isPull bool) ([]*Issue, | |||
return nil, err | |||
} | |||
err = IssueList(issues).LoadAttributes() | |||
err = IssueList(issues).LoadAttributes(ctx) | |||
if err != nil { | |||
return nil, err | |||
} |
@@ -526,7 +526,7 @@ func (issues IssueList) loadTotalTrackedTimes(ctx context.Context) (err error) { | |||
} | |||
// loadAttributes loads all attributes, expect for attachments and comments | |||
func (issues IssueList) loadAttributes(ctx context.Context) error { | |||
func (issues IssueList) LoadAttributes(ctx context.Context) error { | |||
if _, err := issues.LoadRepositories(ctx); err != nil { | |||
return fmt.Errorf("issue.loadAttributes: LoadRepositories: %w", err) | |||
} | |||
@@ -562,12 +562,6 @@ func (issues IssueList) loadAttributes(ctx context.Context) error { | |||
return nil | |||
} | |||
// LoadAttributes loads attributes of the issues, except for attachments and | |||
// comments | |||
func (issues IssueList) LoadAttributes() error { | |||
return issues.loadAttributes(db.DefaultContext) | |||
} | |||
// LoadComments loads comments | |||
func (issues IssueList) LoadComments(ctx context.Context) error { | |||
return issues.loadComments(ctx, builder.NewCond()) |
@@ -39,7 +39,7 @@ func TestIssueList_LoadAttributes(t *testing.T) { | |||
unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 4}), | |||
} | |||
assert.NoError(t, issueList.LoadAttributes()) | |||
assert.NoError(t, issueList.LoadAttributes(db.DefaultContext)) | |||
for _, issue := range issueList { | |||
assert.EqualValues(t, issue.RepoID, issue.Repo.ID) | |||
for _, label := range issue.Labels { |
@@ -440,7 +440,7 @@ func Issues(ctx context.Context, opts *IssuesOptions) ([]*Issue, error) { | |||
return nil, fmt.Errorf("unable to query Issues: %w", err) | |||
} | |||
if err := issues.LoadAttributes(); err != nil { | |||
if err := issues.LoadAttributes(ctx); err != nil { | |||
return nil, fmt.Errorf("unable to LoadAttributes for Issues: %w", err) | |||
} | |||
@@ -51,16 +51,16 @@ func listPullRequestStatement(baseRepoID int64, opts *PullRequestsOptions) (*xor | |||
} | |||
// GetUnmergedPullRequestsByHeadInfo returns all pull requests that are open and has not been merged | |||
func GetUnmergedPullRequestsByHeadInfo(repoID int64, branch string) ([]*PullRequest, error) { | |||
func GetUnmergedPullRequestsByHeadInfo(ctx context.Context, repoID int64, branch string) ([]*PullRequest, error) { | |||
prs := make([]*PullRequest, 0, 2) | |||
sess := db.GetEngine(db.DefaultContext). | |||
sess := db.GetEngine(ctx). | |||
Join("INNER", "issue", "issue.id = pull_request.issue_id"). | |||
Where("head_repo_id = ? AND head_branch = ? AND has_merged = ? AND issue.is_closed = ? AND flow = ?", repoID, branch, false, false, PullRequestFlowGithub) | |||
return prs, sess.Find(&prs) | |||
} | |||
// CanMaintainerWriteToBranch check whether user is a maintainer and could write to the branch | |||
func CanMaintainerWriteToBranch(p access_model.Permission, branch string, user *user_model.User) bool { | |||
func CanMaintainerWriteToBranch(ctx context.Context, p access_model.Permission, branch string, user *user_model.User) bool { | |||
if p.CanWrite(unit.TypeCode) { | |||
return true | |||
} | |||
@@ -69,18 +69,18 @@ func CanMaintainerWriteToBranch(p access_model.Permission, branch string, user * | |||
return false | |||
} | |||
prs, err := GetUnmergedPullRequestsByHeadInfo(p.Units[0].RepoID, branch) | |||
prs, err := GetUnmergedPullRequestsByHeadInfo(ctx, p.Units[0].RepoID, branch) | |||
if err != nil { | |||
return false | |||
} | |||
for _, pr := range prs { | |||
if pr.AllowMaintainerEdit { | |||
err = pr.LoadBaseRepo(db.DefaultContext) | |||
err = pr.LoadBaseRepo(ctx) | |||
if err != nil { | |||
continue | |||
} | |||
prPerm, err := access_model.GetUserRepoPermission(db.DefaultContext, pr.BaseRepo, user) | |||
prPerm, err := access_model.GetUserRepoPermission(ctx, pr.BaseRepo, user) | |||
if err != nil { | |||
continue | |||
} | |||
@@ -104,9 +104,9 @@ func HasUnmergedPullRequestsByHeadInfo(ctx context.Context, repoID int64, branch | |||
// GetUnmergedPullRequestsByBaseInfo returns all pull requests that are open and has not been merged | |||
// by given base information (repo and branch). | |||
func GetUnmergedPullRequestsByBaseInfo(repoID int64, branch string) ([]*PullRequest, error) { | |||
func GetUnmergedPullRequestsByBaseInfo(ctx context.Context, repoID int64, branch string) ([]*PullRequest, error) { | |||
prs := make([]*PullRequest, 0, 2) | |||
return prs, db.GetEngine(db.DefaultContext). | |||
return prs, db.GetEngine(ctx). | |||
Where("base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?", | |||
repoID, branch, false, false). | |||
OrderBy("issue.updated_unix DESC"). | |||
@@ -154,7 +154,7 @@ func PullRequests(baseRepoID int64, opts *PullRequestsOptions) ([]*PullRequest, | |||
// PullRequestList defines a list of pull requests | |||
type PullRequestList []*PullRequest | |||
func (prs PullRequestList) loadAttributes(ctx context.Context) error { | |||
func (prs PullRequestList) LoadAttributes(ctx context.Context) error { | |||
if len(prs) == 0 { | |||
return nil | |||
} | |||
@@ -199,8 +199,3 @@ func (prs PullRequestList) GetIssueIDs() []int64 { | |||
} | |||
return issueIDs | |||
} | |||
// LoadAttributes load all the prs attributes | |||
func (prs PullRequestList) LoadAttributes() error { | |||
return prs.loadAttributes(db.DefaultContext) | |||
} |
@@ -148,7 +148,7 @@ func TestHasUnmergedPullRequestsByHeadInfo(t *testing.T) { | |||
func TestGetUnmergedPullRequestsByHeadInfo(t *testing.T) { | |||
assert.NoError(t, unittest.PrepareTestDatabase()) | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(1, "branch2") | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(db.DefaultContext, 1, "branch2") | |||
assert.NoError(t, err) | |||
assert.Len(t, prs, 1) | |||
for _, pr := range prs { | |||
@@ -159,7 +159,7 @@ func TestGetUnmergedPullRequestsByHeadInfo(t *testing.T) { | |||
func TestGetUnmergedPullRequestsByBaseInfo(t *testing.T) { | |||
assert.NoError(t, unittest.PrepareTestDatabase()) | |||
prs, err := issues_model.GetUnmergedPullRequestsByBaseInfo(1, "master") | |||
prs, err := issues_model.GetUnmergedPullRequestsByBaseInfo(db.DefaultContext, 1, "master") | |||
assert.NoError(t, err) | |||
assert.Len(t, prs, 1) | |||
pr := prs[0] | |||
@@ -242,13 +242,13 @@ func TestPullRequestList_LoadAttributes(t *testing.T) { | |||
unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 1}), | |||
unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 2}), | |||
} | |||
assert.NoError(t, issues_model.PullRequestList(prs).LoadAttributes()) | |||
assert.NoError(t, issues_model.PullRequestList(prs).LoadAttributes(db.DefaultContext)) | |||
for _, pr := range prs { | |||
assert.NotNil(t, pr.Issue) | |||
assert.Equal(t, pr.IssueID, pr.Issue.ID) | |||
} | |||
assert.NoError(t, issues_model.PullRequestList([]*issues_model.PullRequest{}).LoadAttributes()) | |||
assert.NoError(t, issues_model.PullRequestList([]*issues_model.PullRequest{}).LoadAttributes(db.DefaultContext)) | |||
} | |||
// TODO TestAddTestPullRequestTask |
@@ -43,11 +43,7 @@ func (t *TrackedTime) AfterLoad() { | |||
} | |||
// LoadAttributes load Issue, User | |||
func (t *TrackedTime) LoadAttributes() (err error) { | |||
return t.loadAttributes(db.DefaultContext) | |||
} | |||
func (t *TrackedTime) loadAttributes(ctx context.Context) (err error) { | |||
func (t *TrackedTime) LoadAttributes(ctx context.Context) (err error) { | |||
// Load the issue | |||
if t.Issue == nil { | |||
t.Issue, err = GetIssueByID(ctx, t.IssueID) | |||
@@ -76,9 +72,9 @@ func (t *TrackedTime) loadAttributes(ctx context.Context) (err error) { | |||
} | |||
// LoadAttributes load Issue, User | |||
func (tl TrackedTimeList) LoadAttributes() error { | |||
func (tl TrackedTimeList) LoadAttributes(ctx context.Context) error { | |||
for _, t := range tl { | |||
if err := t.LoadAttributes(); err != nil { | |||
if err := t.LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
} | |||
@@ -143,8 +139,8 @@ func GetTrackedTimes(ctx context.Context, options *FindTrackedTimesOptions) (tra | |||
} | |||
// CountTrackedTimes returns count of tracked times that fit to the given options. | |||
func CountTrackedTimes(opts *FindTrackedTimesOptions) (int64, error) { | |||
sess := db.GetEngine(db.DefaultContext).Where(opts.toCond()) | |||
func CountTrackedTimes(ctx context.Context, opts *FindTrackedTimesOptions) (int64, error) { | |||
sess := db.GetEngine(ctx).Where(opts.toCond()) | |||
if opts.RepositoryID > 0 || opts.MilestoneID > 0 { | |||
sess = sess.Join("INNER", "issue", "issue.id = tracked_time.issue_id") | |||
} | |||
@@ -157,8 +153,8 @@ func GetTrackedSeconds(ctx context.Context, opts FindTrackedTimesOptions) (track | |||
} | |||
// AddTime will add the given time (in seconds) to the issue | |||
func AddTime(user *user_model.User, issue *Issue, amount int64, created time.Time) (*TrackedTime, error) { | |||
ctx, committer, err := db.TxContext(db.DefaultContext) | |||
func AddTime(ctx context.Context, user *user_model.User, issue *Issue, amount int64, created time.Time) (*TrackedTime, error) { | |||
ctx, committer, err := db.TxContext(ctx) | |||
if err != nil { | |||
return nil, err | |||
} | |||
@@ -276,7 +272,7 @@ func DeleteTime(t *TrackedTime) error { | |||
} | |||
defer committer.Close() | |||
if err := t.loadAttributes(ctx); err != nil { | |||
if err := t.LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
@@ -25,7 +25,7 @@ func TestAddTime(t *testing.T) { | |||
assert.NoError(t, err) | |||
// 3661 = 1h 1min 1s | |||
trackedTime, err := issues_model.AddTime(user3, issue1, 3661, time.Now()) | |||
trackedTime, err := issues_model.AddTime(db.DefaultContext, user3, issue1, 3661, time.Now()) | |||
assert.NoError(t, err) | |||
assert.Equal(t, int64(3), trackedTime.UserID) | |||
assert.Equal(t, int64(1), trackedTime.IssueID) |
@@ -128,8 +128,8 @@ func InsertIssueComments(comments []*issues_model.Comment) error { | |||
} | |||
// InsertPullRequests inserted pull requests | |||
func InsertPullRequests(prs ...*issues_model.PullRequest) error { | |||
ctx, committer, err := db.TxContext(db.DefaultContext) | |||
func InsertPullRequests(ctx context.Context, prs ...*issues_model.PullRequest) error { | |||
ctx, committer, err := db.TxContext(ctx) | |||
if err != nil { | |||
return err | |||
} |
@@ -122,7 +122,7 @@ func TestMigrate_InsertPullRequests(t *testing.T) { | |||
Issue: i, | |||
} | |||
err := InsertPullRequests(p) | |||
err := InsertPullRequests(db.DefaultContext, p) | |||
assert.NoError(t, err) | |||
_ = unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{IssueID: i.ID}) |
@@ -35,7 +35,7 @@ func RequireRepoWriter(unitType unit.Type) func(ctx *Context) { | |||
// CanEnableEditor checks if the user is allowed to write to the branch of the repo | |||
func CanEnableEditor() func(ctx *Context) { | |||
return func(ctx *Context) { | |||
if !ctx.Repo.CanWriteToBranch(ctx.Doer, ctx.Repo.BranchName) { | |||
if !ctx.Repo.CanWriteToBranch(ctx, ctx.Doer, ctx.Repo.BranchName) { | |||
ctx.NotFound("CanWriteToBranch denies permission", nil) | |||
return | |||
} |
@@ -66,13 +66,13 @@ type Repository struct { | |||
} | |||
// CanWriteToBranch checks if the branch is writable by the user | |||
func (r *Repository) CanWriteToBranch(user *user_model.User, branch string) bool { | |||
return issues_model.CanMaintainerWriteToBranch(r.Permission, branch, user) | |||
func (r *Repository) CanWriteToBranch(ctx context.Context, user *user_model.User, branch string) bool { | |||
return issues_model.CanMaintainerWriteToBranch(ctx, r.Permission, branch, user) | |||
} | |||
// CanEnableEditor returns true if repository is editable and user has proper access level. | |||
func (r *Repository) CanEnableEditor(user *user_model.User) bool { | |||
return r.IsViewBranch && r.CanWriteToBranch(user, r.BranchName) && r.Repository.CanEnableEditor() && !r.Repository.IsArchived | |||
func (r *Repository) CanEnableEditor(ctx context.Context, user *user_model.User) bool { | |||
return r.IsViewBranch && r.CanWriteToBranch(ctx, user, r.BranchName) && r.Repository.CanEnableEditor() && !r.Repository.IsArchived | |||
} | |||
// CanCreateBranch returns true if repository is editable and user has proper access level. | |||
@@ -118,7 +118,7 @@ func (r *Repository) CanCommitToBranch(ctx context.Context, doer *user_model.Use | |||
sign, keyID, _, err := asymkey_service.SignCRUDAction(ctx, r.Repository.RepoPath(), doer, r.Repository.RepoPath(), git.BranchPrefix+r.BranchName) | |||
canCommit := r.CanEnableEditor(doer) && userCanPush | |||
canCommit := r.CanEnableEditor(ctx, doer) && userCanPush | |||
if requireSigned { | |||
canCommit = canCommit && sign | |||
} | |||
@@ -134,7 +134,7 @@ func (r *Repository) CanCommitToBranch(ctx context.Context, doer *user_model.Use | |||
return CanCommitToBranchResults{ | |||
CanCommitToBranch: canCommit, | |||
EditorEnabled: r.CanEnableEditor(doer), | |||
EditorEnabled: r.CanEnableEditor(ctx, doer), | |||
UserCanPush: userCanPush, | |||
RequireSigned: requireSigned, | |||
WillSign: sign, |
@@ -386,7 +386,7 @@ func reqRepoWriter(unitTypes ...unit.Type) func(ctx *context.APIContext) { | |||
// reqRepoBranchWriter user should have a permission to write to a branch, or be a site admin | |||
func reqRepoBranchWriter(ctx *context.APIContext) { | |||
options, ok := web.GetForm(ctx).(api.FileOptionInterface) | |||
if !ok || (!ctx.Repo.CanWriteToBranch(ctx.Doer, options.Branch()) && !ctx.IsUserSiteAdmin()) { | |||
if !ok || (!ctx.Repo.CanWriteToBranch(ctx, ctx.Doer, options.Branch()) && !ctx.IsUserSiteAdmin()) { | |||
ctx.Error(http.StatusForbidden, "reqRepoBranchWriter", "user should have a permission to write to this branch") | |||
return | |||
} |
@@ -644,7 +644,7 @@ func CreateBranchProtection(ctx *context.APIContext) { | |||
} | |||
if isBranchExist { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx.Repo.Repository, ruleName); err != nil { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx, ctx.Repo.Repository, ruleName); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "CheckPRsForBaseBranch", err) | |||
return | |||
} | |||
@@ -669,7 +669,7 @@ func CreateBranchProtection(ctx *context.APIContext) { | |||
} | |||
for _, branchName := range matchedBranches { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx.Repo.Repository, branchName); err != nil { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx, ctx.Repo.Repository, branchName); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "CheckPRsForBaseBranch", err) | |||
return | |||
} | |||
@@ -914,7 +914,7 @@ func EditBranchProtection(ctx *context.APIContext) { | |||
} | |||
if isBranchExist { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx.Repo.Repository, bpName); err != nil { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx, ctx.Repo.Repository, bpName); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "CheckPrsForBaseBranch", err) | |||
return | |||
} | |||
@@ -940,7 +940,7 @@ func EditBranchProtection(ctx *context.APIContext) { | |||
} | |||
for _, branchName := range matchedBranches { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx.Repo.Repository, branchName); err != nil { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx, ctx.Repo.Repository, branchName); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "CheckPrsForBaseBranch", err) | |||
return | |||
} |
@@ -398,7 +398,7 @@ func GetEditorconfig(ctx *context.APIContext) { | |||
// canWriteFiles returns true if repository is editable and user has proper access level. | |||
func canWriteFiles(ctx *context.APIContext, branch string) bool { | |||
return ctx.Repo.CanWriteToBranch(ctx.Doer, branch) && | |||
return ctx.Repo.CanWriteToBranch(ctx, ctx.Doer, branch) && | |||
!ctx.Repo.Repository.IsMirror && | |||
!ctx.Repo.Repository.IsArchived | |||
} |
@@ -552,7 +552,7 @@ func GetIssue(ctx *context.APIContext) { | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -661,7 +661,7 @@ func CreateIssue(ctx *context.APIContext) { | |||
} | |||
if form.Closed { | |||
if err := issue_service.ChangeStatus(issue, ctx.Doer, "", true); err != nil { | |||
if err := issue_service.ChangeStatus(ctx, issue, ctx.Doer, "", true); err != nil { | |||
if issues_model.IsErrDependenciesLeft(err) { | |||
ctx.Error(http.StatusPreconditionFailed, "DependenciesLeft", "cannot close this issue because it still has open dependencies") | |||
return | |||
@@ -721,7 +721,7 @@ func EditIssue(ctx *context.APIContext) { | |||
// "$ref": "#/responses/error" | |||
form := web.GetForm(ctx).(*api.EditIssueOption) | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -877,7 +877,7 @@ func DeleteIssue(ctx *context.APIContext) { | |||
// "$ref": "#/responses/forbidden" | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound(err) | |||
@@ -933,7 +933,7 @@ func UpdateIssueDeadline(ctx *context.APIContext) { | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
form := web.GetForm(ctx).(*api.EditDeadlineOption) | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() |
@@ -307,7 +307,7 @@ func DeleteIssueAttachment(ctx *context.APIContext) { | |||
} | |||
func getIssueFromContext(ctx *context.APIContext) *issues_model.Issue { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64("index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64("index")) | |||
if err != nil { | |||
ctx.NotFoundOrServerError("GetIssueByIndex", issues_model.IsErrIssueNotExist, err) | |||
return nil |
@@ -64,7 +64,7 @@ func ListIssueComments(ctx *context.APIContext) { | |||
ctx.Error(http.StatusUnprocessableEntity, "GetQueryBeforeSince", err) | |||
return | |||
} | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
ctx.Error(http.StatusInternalServerError, "GetRawIssueByIndex", err) | |||
return | |||
@@ -161,7 +161,7 @@ func ListIssueCommentsAndTimeline(ctx *context.APIContext) { | |||
ctx.Error(http.StatusUnprocessableEntity, "GetQueryBeforeSince", err) | |||
return | |||
} | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
ctx.Error(http.StatusInternalServerError, "GetRawIssueByIndex", err) | |||
return | |||
@@ -351,7 +351,7 @@ func CreateIssueComment(ctx *context.APIContext) { | |||
// "403": | |||
// "$ref": "#/responses/forbidden" | |||
form := web.GetForm(ctx).(*api.CreateIssueCommentOption) | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err) | |||
return |
@@ -59,7 +59,7 @@ func GetIssueDependencies(ctx *context.APIContext) { | |||
return | |||
} | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound("IsErrIssueNotExist", err) | |||
@@ -484,7 +484,7 @@ func RemoveIssueBlocking(ctx *context.APIContext) { | |||
} | |||
func getParamsIssue(ctx *context.APIContext) *issues_model.Issue { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound("IsErrIssueNotExist", err) | |||
@@ -518,7 +518,7 @@ func getFormIssue(ctx *context.APIContext, form *api.IssueMeta) *issues_model.Is | |||
repo = ctx.Repo.Repository | |||
} | |||
issue, err := issues_model.GetIssueByIndex(repo.ID, form.Index) | |||
issue, err := issues_model.GetIssueByIndex(ctx, repo.ID, form.Index) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound("IsErrIssueNotExist", err) |
@@ -45,7 +45,7 @@ func ListIssueLabels(ctx *context.APIContext) { | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -157,7 +157,7 @@ func DeleteIssueLabel(ctx *context.APIContext) { | |||
// "422": | |||
// "$ref": "#/responses/validationError" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -275,7 +275,7 @@ func ClearIssueLabels(ctx *context.APIContext) { | |||
// "403": | |||
// "$ref": "#/responses/forbidden" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -299,7 +299,7 @@ func ClearIssueLabels(ctx *context.APIContext) { | |||
} | |||
func prepareForReplaceOrAdd(ctx *context.APIContext, form api.IssueLabelsOption) (*issues_model.Issue, []*issues_model.Label, error) { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() |
@@ -41,7 +41,7 @@ func PinIssue(ctx *context.APIContext) { | |||
// "$ref": "#/responses/forbidden" | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -98,7 +98,7 @@ func UnpinIssue(ctx *context.APIContext) { | |||
// "$ref": "#/responses/forbidden" | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -159,7 +159,7 @@ func MoveIssuePin(ctx *context.APIContext) { | |||
// "$ref": "#/responses/forbidden" | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() |
@@ -269,7 +269,7 @@ func GetIssueReactions(ctx *context.APIContext) { | |||
// "403": | |||
// "$ref": "#/responses/forbidden" | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -389,7 +389,7 @@ func DeleteIssueReaction(ctx *context.APIContext) { | |||
} | |||
func changeIssueReaction(ctx *context.APIContext, form api.EditReactionOption, isCreateType bool) { | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() |
@@ -161,7 +161,7 @@ func DeleteIssueStopwatch(ctx *context.APIContext) { | |||
} | |||
func prepareIssueStopwatch(ctx *context.APIContext, shouldExist bool) (*issues_model.Issue, error) { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() |
@@ -104,7 +104,7 @@ func DelIssueSubscription(ctx *context.APIContext) { | |||
} | |||
func setIssueSubscription(ctx *context.APIContext, watch bool) { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -185,7 +185,7 @@ func CheckIssueSubscription(ctx *context.APIContext) { | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() | |||
@@ -251,7 +251,7 @@ func GetIssueSubscribers(ctx *context.APIContext) { | |||
// "404": | |||
// "$ref": "#/responses/notFound" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound() |
@@ -75,7 +75,7 @@ func ListTrackedTimes(ctx *context.APIContext) { | |||
ctx.NotFound("Timetracker is disabled") | |||
return | |||
} | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound(err) | |||
@@ -121,7 +121,7 @@ func ListTrackedTimes(ctx *context.APIContext) { | |||
} | |||
} | |||
count, err := issues_model.CountTrackedTimes(opts) | |||
count, err := issues_model.CountTrackedTimes(ctx, opts) | |||
if err != nil { | |||
ctx.InternalServerError(err) | |||
return | |||
@@ -132,7 +132,7 @@ func ListTrackedTimes(ctx *context.APIContext) { | |||
ctx.Error(http.StatusInternalServerError, "GetTrackedTimes", err) | |||
return | |||
} | |||
if err = trackedTimes.LoadAttributes(); err != nil { | |||
if err = trackedTimes.LoadAttributes(ctx); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "LoadAttributes", err) | |||
return | |||
} | |||
@@ -179,7 +179,7 @@ func AddTime(ctx *context.APIContext) { | |||
// "403": | |||
// "$ref": "#/responses/forbidden" | |||
form := web.GetForm(ctx).(*api.AddTimeOption) | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound(err) | |||
@@ -214,12 +214,12 @@ func AddTime(ctx *context.APIContext) { | |||
created = form.Created | |||
} | |||
trackedTime, err := issues_model.AddTime(user, issue, form.Time, created) | |||
trackedTime, err := issues_model.AddTime(ctx, user, issue, form.Time, created) | |||
if err != nil { | |||
ctx.Error(http.StatusInternalServerError, "AddTime", err) | |||
return | |||
} | |||
if err = trackedTime.LoadAttributes(); err != nil { | |||
if err = trackedTime.LoadAttributes(ctx); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "LoadAttributes", err) | |||
return | |||
} | |||
@@ -260,7 +260,7 @@ func ResetIssueTime(ctx *context.APIContext) { | |||
// "403": | |||
// "$ref": "#/responses/forbidden" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound(err) | |||
@@ -331,7 +331,7 @@ func DeleteTime(ctx *context.APIContext) { | |||
// "403": | |||
// "$ref": "#/responses/forbidden" | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound(err) | |||
@@ -443,7 +443,7 @@ func ListTrackedTimesByUser(ctx *context.APIContext) { | |||
ctx.Error(http.StatusInternalServerError, "GetTrackedTimes", err) | |||
return | |||
} | |||
if err = trackedTimes.LoadAttributes(); err != nil { | |||
if err = trackedTimes.LoadAttributes(ctx); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "LoadAttributes", err) | |||
return | |||
} | |||
@@ -540,7 +540,7 @@ func ListTrackedTimesByRepository(ctx *context.APIContext) { | |||
} | |||
} | |||
count, err := issues_model.CountTrackedTimes(opts) | |||
count, err := issues_model.CountTrackedTimes(ctx, opts) | |||
if err != nil { | |||
ctx.InternalServerError(err) | |||
return | |||
@@ -551,7 +551,7 @@ func ListTrackedTimesByRepository(ctx *context.APIContext) { | |||
ctx.Error(http.StatusInternalServerError, "GetTrackedTimes", err) | |||
return | |||
} | |||
if err = trackedTimes.LoadAttributes(); err != nil { | |||
if err = trackedTimes.LoadAttributes(ctx); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "LoadAttributes", err) | |||
return | |||
} | |||
@@ -601,7 +601,7 @@ func ListMyTrackedTimes(ctx *context.APIContext) { | |||
return | |||
} | |||
count, err := issues_model.CountTrackedTimes(opts) | |||
count, err := issues_model.CountTrackedTimes(ctx, opts) | |||
if err != nil { | |||
ctx.InternalServerError(err) | |||
return | |||
@@ -613,7 +613,7 @@ func ListMyTrackedTimes(ctx *context.APIContext) { | |||
return | |||
} | |||
if err = trackedTimes.LoadAttributes(); err != nil { | |||
if err = trackedTimes.LoadAttributes(ctx); err != nil { | |||
ctx.Error(http.StatusInternalServerError, "LoadAttributes", err) | |||
return | |||
} |
@@ -55,7 +55,7 @@ func (ctx *preReceiveContext) CanWriteCode() bool { | |||
if !ctx.loadPusherAndPermission() { | |||
return false | |||
} | |||
ctx.canWriteCode = issues_model.CanMaintainerWriteToBranch(ctx.userPerm, ctx.branchName, ctx.user) || ctx.deployKeyAccessMode >= perm_model.AccessModeWrite | |||
ctx.canWriteCode = issues_model.CanMaintainerWriteToBranch(ctx, ctx.userPerm, ctx.branchName, ctx.user) || ctx.deployKeyAccessMode >= perm_model.AccessModeWrite | |||
ctx.checkedCanWriteCode = true | |||
} | |||
return ctx.canWriteCode |
@@ -220,7 +220,7 @@ func feedActionsToFeedItems(ctx *context.Context, actions activities_model.Actio | |||
case activities_model.ActionCreateIssue, activities_model.ActionCreatePullRequest: | |||
desc = strings.Join(act.GetIssueInfos(), "#") | |||
content = renderMarkdown(ctx, act, act.GetIssueContent()) | |||
content = renderMarkdown(ctx, act, act.GetIssueContent(ctx)) | |||
case activities_model.ActionCommentIssue, activities_model.ActionApprovePullRequest, activities_model.ActionRejectPullRequest, activities_model.ActionCommentPull: | |||
desc = act.GetIssueTitle() | |||
comment := act.GetIssueInfos()[1] |
@@ -1278,7 +1278,7 @@ func ViewIssue(ctx *context.Context) { | |||
} | |||
} | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound("GetIssueByIndex", err) | |||
@@ -1981,7 +1981,7 @@ func sortDependencyInfo(blockers []*issues_model.DependencyInfo) { | |||
// GetActionIssue will return the issue which is used in the context. | |||
func GetActionIssue(ctx *context.Context) *issues_model.Issue { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
ctx.NotFoundOrServerError("GetIssueByIndex", issues_model.IsErrIssueNotExist, err) | |||
return nil | |||
@@ -2046,7 +2046,7 @@ func getActionIssues(ctx *context.Context) issues_model.IssueList { | |||
// GetIssueInfo get an issue of a repository | |||
func GetIssueInfo(ctx *context.Context) { | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueWithAttrsByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.Error(http.StatusNotFound) | |||
@@ -2170,7 +2170,7 @@ func UpdateIssueContent(ctx *context.Context) { | |||
// UpdateIssueDeadline updates an issue deadline | |||
func UpdateIssueDeadline(ctx *context.Context) { | |||
form := web.GetForm(ctx).(*api.EditDeadlineOption) | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound("GetIssueByIndex", err) | |||
@@ -2784,7 +2784,7 @@ func UpdateIssueStatus(ctx *context.Context) { | |||
continue | |||
} | |||
if issue.IsClosed != isClosed { | |||
if err := issue_service.ChangeStatus(issue, ctx.Doer, "", isClosed); err != nil { | |||
if err := issue_service.ChangeStatus(ctx, issue, ctx.Doer, "", isClosed); err != nil { | |||
if issues_model.IsErrDependenciesLeft(err) { | |||
ctx.JSON(http.StatusPreconditionFailed, map[string]any{ | |||
"error": ctx.Tr("repo.issues.dependency.issue_batch_close_blocked", issue.Index), | |||
@@ -2869,7 +2869,7 @@ func NewComment(ctx *context.Context) { | |||
// Regenerate patch and test conflict. | |||
if pr == nil { | |||
issue.PullRequest.HeadCommitID = "" | |||
pull_service.AddToTaskQueue(issue.PullRequest) | |||
pull_service.AddToTaskQueue(ctx, issue.PullRequest) | |||
} | |||
// check whether the ref of PR <refs/pulls/pr_index/head> in base repo is consistent with the head commit of head branch in the head repo | |||
@@ -2927,7 +2927,7 @@ func NewComment(ctx *context.Context) { | |||
ctx.Flash.Info(ctx.Tr("repo.pulls.open_unmerged_pull_exists", pr.Index)) | |||
} else { | |||
isClosed := form.Status == "close" | |||
if err := issue_service.ChangeStatus(issue, ctx.Doer, "", isClosed); err != nil { | |||
if err := issue_service.ChangeStatus(ctx, issue, ctx.Doer, "", isClosed); err != nil { | |||
log.Error("ChangeStatus: %v", err) | |||
if issues_model.IsErrDependenciesLeft(err) { |
@@ -15,7 +15,7 @@ import ( | |||
// AddDependency adds new dependencies | |||
func AddDependency(ctx *context.Context) { | |||
issueIndex := ctx.ParamsInt64("index") | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, issueIndex) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, issueIndex) | |||
if err != nil { | |||
ctx.ServerError("GetIssueByIndex", err) | |||
return | |||
@@ -90,7 +90,7 @@ func AddDependency(ctx *context.Context) { | |||
// RemoveDependency removes the dependency | |||
func RemoveDependency(ctx *context.Context) { | |||
issueIndex := ctx.ParamsInt64("index") | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, issueIndex) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, issueIndex) | |||
if err != nil { | |||
ctx.ServerError("GetIssueByIndex", err) | |||
return |
@@ -39,7 +39,7 @@ func IssuePinOrUnpin(ctx *context.Context) { | |||
// IssueUnpin unpins a Issue | |||
func IssueUnpin(ctx *context.Context) { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
ctx.Status(http.StatusInternalServerError) | |||
log.Error(err.Error()) |
@@ -42,7 +42,7 @@ func AddTimeManually(c *context.Context) { | |||
return | |||
} | |||
if _, err := issues_model.AddTime(c.Doer, issue, int64(total.Seconds()), time.Now()); err != nil { | |||
if _, err := issues_model.AddTime(c, c.Doer, issue, int64(total.Seconds()), time.Now()); err != nil { | |||
c.ServerError("AddTime", err) | |||
return | |||
} |
@@ -300,7 +300,7 @@ func ForkPost(ctx *context.Context) { | |||
} | |||
func checkPullInfo(ctx *context.Context) *issues_model.Issue { | |||
issue, err := issues_model.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index")) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
ctx.NotFound("GetIssueByIndex", err) |
@@ -303,7 +303,7 @@ func SettingsProtectedBranchPost(ctx *context.Context) { | |||
return | |||
} | |||
for _, branchName := range matchedBranches { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx.Repo.Repository, branchName); err != nil { | |||
if err = pull_service.CheckPRsForBaseBranch(ctx, ctx.Repo.Repository, branchName); err != nil { | |||
ctx.ServerError("CheckPRsForBaseBranch", err) | |||
return | |||
} |
@@ -530,7 +530,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st | |||
ctx.Data["LineEscapeStatus"] = statuses | |||
} | |||
if !fInfo.isLFSFile { | |||
if ctx.Repo.CanEnableEditor(ctx.Doer) { | |||
if ctx.Repo.CanEnableEditor(ctx, ctx.Doer) { | |||
if lfsLock != nil && lfsLock.OwnerID != ctx.Doer.ID { | |||
ctx.Data["CanEditFile"] = false | |||
ctx.Data["EditFileTooltip"] = ctx.Tr("repo.editor.this_file_locked") | |||
@@ -540,7 +540,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st | |||
} | |||
} else if !ctx.Repo.IsViewBranch { | |||
ctx.Data["EditFileTooltip"] = ctx.Tr("repo.editor.must_be_on_a_branch") | |||
} else if !ctx.Repo.CanWriteToBranch(ctx.Doer, ctx.Repo.BranchName) { | |||
} else if !ctx.Repo.CanWriteToBranch(ctx, ctx.Doer, ctx.Repo.BranchName) { | |||
ctx.Data["EditFileTooltip"] = ctx.Tr("repo.editor.fork_before_edit") | |||
} | |||
} | |||
@@ -578,7 +578,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st | |||
} | |||
} | |||
if ctx.Repo.CanEnableEditor(ctx.Doer) { | |||
if ctx.Repo.CanEnableEditor(ctx, ctx.Doer) { | |||
if lfsLock != nil && lfsLock.OwnerID != ctx.Doer.ID { | |||
ctx.Data["CanDeleteFile"] = false | |||
ctx.Data["DeleteFileTooltip"] = ctx.Tr("repo.editor.this_file_locked") | |||
@@ -588,7 +588,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st | |||
} | |||
} else if !ctx.Repo.IsViewBranch { | |||
ctx.Data["DeleteFileTooltip"] = ctx.Tr("repo.editor.must_be_on_a_branch") | |||
} else if !ctx.Repo.CanWriteToBranch(ctx.Doer, ctx.Repo.BranchName) { | |||
} else if !ctx.Repo.CanWriteToBranch(ctx, ctx.Doer, ctx.Repo.BranchName) { | |||
ctx.Data["DeleteFileTooltip"] = ctx.Tr("repo.editor.must_have_write_access") | |||
} | |||
} |
@@ -197,7 +197,7 @@ func ProcReceive(ctx context.Context, repo *repo_model.Repository, gitRepo *git. | |||
return nil, fmt.Errorf("Failed to update pull ref. Error: %w", err) | |||
} | |||
pull_service.AddToTaskQueue(pr) | |||
pull_service.AddToTaskQueue(ctx, pr) | |||
pusher, err := user_model.GetUserByID(ctx, opts.UserID) | |||
if err != nil { | |||
return nil, fmt.Errorf("Failed to get user. Error: %w", err) |
@@ -56,16 +56,16 @@ func ToBranch(ctx context.Context, repo *repo_model.Repository, branchName strin | |||
var canPush bool | |||
var err error | |||
if user != nil { | |||
hasPerm, err = access_model.HasAccessUnit(db.DefaultContext, user, repo, unit.TypeCode, perm.AccessModeWrite) | |||
hasPerm, err = access_model.HasAccessUnit(ctx, user, repo, unit.TypeCode, perm.AccessModeWrite) | |||
if err != nil { | |||
return nil, err | |||
} | |||
perms, err := access_model.GetUserRepoPermission(db.DefaultContext, repo, user) | |||
perms, err := access_model.GetUserRepoPermission(ctx, repo, user) | |||
if err != nil { | |||
return nil, err | |||
} | |||
canPush = issues_model.CanMaintainerWriteToBranch(perms, branchName, user) | |||
canPush = issues_model.CanMaintainerWriteToBranch(ctx, perms, branchName, user) | |||
} | |||
return &api.Branch{ | |||
@@ -94,13 +94,13 @@ func ToBranch(ctx context.Context, repo *repo_model.Repository, branchName strin | |||
} | |||
if user != nil { | |||
permission, err := access_model.GetUserRepoPermission(db.DefaultContext, repo, user) | |||
permission, err := access_model.GetUserRepoPermission(ctx, repo, user) | |||
if err != nil { | |||
return nil, err | |||
} | |||
bp.Repo = repo | |||
branch.UserCanPush = bp.CanUserPush(db.DefaultContext, user) | |||
branch.UserCanMerge = git_model.IsUserMergeWhitelisted(db.DefaultContext, bp, user.ID, permission) | |||
branch.UserCanPush = bp.CanUserPush(ctx, user) | |||
branch.UserCanMerge = git_model.IsUserMergeWhitelisted(ctx, bp, user.ID, permission) | |||
} | |||
return branch, nil |
@@ -114,7 +114,7 @@ func ToTimelineComment(ctx context.Context, repo *repo_model.Repository, c *issu | |||
} | |||
if c.Time != nil { | |||
err = c.Time.LoadAttributes() | |||
err = c.Time.LoadAttributes(ctx) | |||
if err != nil { | |||
log.Error("Time.LoadAttributes: %v", err) | |||
return nil |
@@ -36,13 +36,13 @@ func CreateComment(ctx context.Context, opts *issues_model.CreateCommentOptions) | |||
} | |||
// CreateRefComment creates a commit reference comment to issue. | |||
func CreateRefComment(doer *user_model.User, repo *repo_model.Repository, issue *issues_model.Issue, content, commitSHA string) error { | |||
func CreateRefComment(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, issue *issues_model.Issue, content, commitSHA string) error { | |||
if len(commitSHA) == 0 { | |||
return fmt.Errorf("cannot create reference with empty commit SHA") | |||
} | |||
// Check if same reference from same commit has already existed. | |||
has, err := db.GetEngine(db.DefaultContext).Get(&issues_model.Comment{ | |||
has, err := db.GetEngine(ctx).Get(&issues_model.Comment{ | |||
Type: issues_model.CommentTypeCommitRef, | |||
IssueID: issue.ID, | |||
CommitSHA: commitSHA, | |||
@@ -53,7 +53,7 @@ func CreateRefComment(doer *user_model.User, repo *repo_model.Repository, issue | |||
return nil | |||
} | |||
_, err = CreateComment(db.DefaultContext, &issues_model.CreateCommentOptions{ | |||
_, err = CreateComment(ctx, &issues_model.CreateCommentOptions{ | |||
Type: issues_model.CommentTypeCommitRef, | |||
Doer: doer, | |||
Repo: repo, |
@@ -4,6 +4,7 @@ | |||
package issue | |||
import ( | |||
"context" | |||
"fmt" | |||
"html" | |||
"net/url" | |||
@@ -12,7 +13,6 @@ import ( | |||
"strings" | |||
"time" | |||
"code.gitea.io/gitea/models/db" | |||
issues_model "code.gitea.io/gitea/models/issues" | |||
access_model "code.gitea.io/gitea/models/perm/access" | |||
repo_model "code.gitea.io/gitea/models/repo" | |||
@@ -78,20 +78,20 @@ func timeLogToAmount(str string) int64 { | |||
return a | |||
} | |||
func issueAddTime(issue *issues_model.Issue, doer *user_model.User, time time.Time, timeLog string) error { | |||
func issueAddTime(ctx context.Context, issue *issues_model.Issue, doer *user_model.User, time time.Time, timeLog string) error { | |||
amount := timeLogToAmount(timeLog) | |||
if amount == 0 { | |||
return nil | |||
} | |||
_, err := issues_model.AddTime(doer, issue, amount, time) | |||
_, err := issues_model.AddTime(ctx, doer, issue, amount, time) | |||
return err | |||
} | |||
// getIssueFromRef returns the issue referenced by a ref. Returns a nil *Issue | |||
// if the provided ref references a non-existent issue. | |||
func getIssueFromRef(repo *repo_model.Repository, index int64) (*issues_model.Issue, error) { | |||
issue, err := issues_model.GetIssueByIndex(repo.ID, index) | |||
func getIssueFromRef(ctx context.Context, repo *repo_model.Repository, index int64) (*issues_model.Issue, error) { | |||
issue, err := issues_model.GetIssueByIndex(ctx, repo.ID, index) | |||
if err != nil { | |||
if issues_model.IsErrIssueNotExist(err) { | |||
return nil, nil | |||
@@ -102,7 +102,7 @@ func getIssueFromRef(repo *repo_model.Repository, index int64) (*issues_model.Is | |||
} | |||
// UpdateIssuesCommit checks if issues are manipulated by commit message. | |||
func UpdateIssuesCommit(doer *user_model.User, repo *repo_model.Repository, commits []*repository.PushCommit, branchName string) error { | |||
func UpdateIssuesCommit(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, commits []*repository.PushCommit, branchName string) error { | |||
// Commits are appended in the reverse order. | |||
for i := len(commits) - 1; i >= 0; i-- { | |||
c := commits[i] | |||
@@ -120,7 +120,7 @@ func UpdateIssuesCommit(doer *user_model.User, repo *repo_model.Repository, comm | |||
// issue is from another repo | |||
if len(ref.Owner) > 0 && len(ref.Name) > 0 { | |||
refRepo, err = repo_model.GetRepositoryByOwnerAndName(db.DefaultContext, ref.Owner, ref.Name) | |||
refRepo, err = repo_model.GetRepositoryByOwnerAndName(ctx, ref.Owner, ref.Name) | |||
if err != nil { | |||
if repo_model.IsErrRepoNotExist(err) { | |||
log.Warn("Repository referenced in commit but does not exist: %v", err) | |||
@@ -132,14 +132,14 @@ func UpdateIssuesCommit(doer *user_model.User, repo *repo_model.Repository, comm | |||
} else { | |||
refRepo = repo | |||
} | |||
if refIssue, err = getIssueFromRef(refRepo, ref.Index); err != nil { | |||
if refIssue, err = getIssueFromRef(ctx, refRepo, ref.Index); err != nil { | |||
return err | |||
} | |||
if refIssue == nil { | |||
continue | |||
} | |||
perm, err := access_model.GetUserRepoPermission(db.DefaultContext, refRepo, doer) | |||
perm, err := access_model.GetUserRepoPermission(ctx, refRepo, doer) | |||
if err != nil { | |||
return err | |||
} | |||
@@ -159,7 +159,7 @@ func UpdateIssuesCommit(doer *user_model.User, repo *repo_model.Repository, comm | |||
} | |||
message := fmt.Sprintf(`<a href="%s/commit/%s">%s</a>`, html.EscapeString(repo.Link()), html.EscapeString(url.PathEscape(c.Sha1)), html.EscapeString(strings.SplitN(c.Message, "\n", 2)[0])) | |||
if err = CreateRefComment(doer, refRepo, refIssue, message, c.Sha1); err != nil { | |||
if err = CreateRefComment(ctx, doer, refRepo, refIssue, message, c.Sha1); err != nil { | |||
return err | |||
} | |||
@@ -187,13 +187,13 @@ func UpdateIssuesCommit(doer *user_model.User, repo *repo_model.Repository, comm | |||
} | |||
close := ref.Action == references.XRefActionCloses | |||
if close && len(ref.TimeLog) > 0 { | |||
if err := issueAddTime(refIssue, doer, c.Timestamp, ref.TimeLog); err != nil { | |||
if err := issueAddTime(ctx, refIssue, doer, c.Timestamp, ref.TimeLog); err != nil { | |||
return err | |||
} | |||
} | |||
if close != refIssue.IsClosed { | |||
refIssue.Repo = refRepo | |||
if err := ChangeStatus(refIssue, doer, c.Sha1, close); err != nil { | |||
if err := ChangeStatus(ctx, refIssue, doer, c.Sha1, close); err != nil { | |||
return err | |||
} | |||
} |
@@ -7,6 +7,7 @@ import ( | |||
"testing" | |||
activities_model "code.gitea.io/gitea/models/activities" | |||
"code.gitea.io/gitea/models/db" | |||
issues_model "code.gitea.io/gitea/models/issues" | |||
repo_model "code.gitea.io/gitea/models/repo" | |||
"code.gitea.io/gitea/models/unittest" | |||
@@ -60,7 +61,7 @@ func TestUpdateIssuesCommit(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, &issues_model.Issue{RepoID: repo.ID, Index: 2}, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch)) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, repo.DefaultBranch)) | |||
unittest.AssertExistsAndLoadBean(t, commentBean) | |||
unittest.AssertExistsAndLoadBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
@@ -87,7 +88,7 @@ func TestUpdateIssuesCommit(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, &issues_model.Issue{RepoID: repo.ID, Index: 1}, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch")) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, "non-existing-branch")) | |||
unittest.AssertExistsAndLoadBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
@@ -113,7 +114,7 @@ func TestUpdateIssuesCommit(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, &issues_model.Issue{RepoID: repo.ID, Index: 1}, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch)) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, repo.DefaultBranch)) | |||
unittest.AssertExistsAndLoadBean(t, commentBean) | |||
unittest.AssertExistsAndLoadBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
@@ -139,7 +140,7 @@ func TestUpdateIssuesCommit_Colon(t *testing.T) { | |||
issueBean := &issues_model.Issue{RepoID: repo.ID, Index: 4} | |||
unittest.AssertNotExistsBean(t, &issues_model.Issue{RepoID: repo.ID, Index: 2}, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch)) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, repo.DefaultBranch)) | |||
unittest.AssertExistsAndLoadBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
} | |||
@@ -172,7 +173,7 @@ func TestUpdateIssuesCommit_Issue5957(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, issueBean, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch")) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, "non-existing-branch")) | |||
unittest.AssertExistsAndLoadBean(t, commentBean) | |||
unittest.AssertExistsAndLoadBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
@@ -207,7 +208,7 @@ func TestUpdateIssuesCommit_AnotherRepo(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, issueBean, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch)) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, repo.DefaultBranch)) | |||
unittest.AssertExistsAndLoadBean(t, commentBean) | |||
unittest.AssertExistsAndLoadBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
@@ -242,7 +243,7 @@ func TestUpdateIssuesCommit_AnotherRepo_FullAddress(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, issueBean, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch)) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, repo.DefaultBranch)) | |||
unittest.AssertExistsAndLoadBean(t, commentBean) | |||
unittest.AssertExistsAndLoadBean(t, issueBean, "is_closed=1") | |||
unittest.CheckConsistencyFor(t, &activities_model.Action{}) | |||
@@ -292,7 +293,7 @@ func TestUpdateIssuesCommit_AnotherRepoNoPermission(t *testing.T) { | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, commentBean2) | |||
unittest.AssertNotExistsBean(t, issueBean, "is_closed=1") | |||
assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch)) | |||
assert.NoError(t, UpdateIssuesCommit(db.DefaultContext, user, repo, pushCommits, repo.DefaultBranch)) | |||
unittest.AssertNotExistsBean(t, commentBean) | |||
unittest.AssertNotExistsBean(t, commentBean2) | |||
unittest.AssertNotExistsBean(t, issueBean, "is_closed=1") |
@@ -6,7 +6,6 @@ package issue | |||
import ( | |||
"context" | |||
"code.gitea.io/gitea/models/db" | |||
issues_model "code.gitea.io/gitea/models/issues" | |||
user_model "code.gitea.io/gitea/models/user" | |||
"code.gitea.io/gitea/modules/log" | |||
@@ -14,13 +13,7 @@ import ( | |||
) | |||
// ChangeStatus changes issue status to open or closed. | |||
func ChangeStatus(issue *issues_model.Issue, doer *user_model.User, commitID string, closed bool) error { | |||
return changeStatusCtx(db.DefaultContext, issue, doer, commitID, closed) | |||
} | |||
// changeStatusCtx changes issue status to open or closed. | |||
// TODO: if context is not db.DefaultContext we get a deadlock!!! | |||
func changeStatusCtx(ctx context.Context, issue *issues_model.Issue, doer *user_model.User, commitID string, closed bool) error { | |||
func ChangeStatus(ctx context.Context, issue *issues_model.Issue, doer *user_model.User, commitID string, closed bool) error { | |||
comment, err := issues_model.ChangeIssueStatus(ctx, issue, doer, closed) | |||
if err != nil { | |||
if issues_model.IsErrDependenciesLeft(err) && closed { |
@@ -515,6 +515,7 @@ func (g *GiteaLocalUploader) CreateComments(comments ...*base.Comment) error { | |||
// CreatePullRequests creates pull requests | |||
func (g *GiteaLocalUploader) CreatePullRequests(prs ...*base.PullRequest) error { | |||
gprs := make([]*issues_model.PullRequest, 0, len(prs)) | |||
ctx := db.DefaultContext | |||
for _, pr := range prs { | |||
gpr, err := g.newPullRequest(pr) | |||
if err != nil { | |||
@@ -527,12 +528,12 @@ func (g *GiteaLocalUploader) CreatePullRequests(prs ...*base.PullRequest) error | |||
gprs = append(gprs, gpr) | |||
} | |||
if err := models.InsertPullRequests(gprs...); err != nil { | |||
if err := models.InsertPullRequests(ctx, gprs...); err != nil { | |||
return err | |||
} | |||
for _, pr := range gprs { | |||
g.issues[pr.Issue.Index] = pr.Issue | |||
pull.AddToTaskQueue(pr) | |||
pull.AddToTaskQueue(ctx, pr) | |||
} | |||
return nil | |||
} |
@@ -43,9 +43,9 @@ var ( | |||
) | |||
// AddToTaskQueue adds itself to pull request test task queue. | |||
func AddToTaskQueue(pr *issues_model.PullRequest) { | |||
func AddToTaskQueue(ctx context.Context, pr *issues_model.PullRequest) { | |||
pr.Status = issues_model.PullRequestStatusChecking | |||
err := pr.UpdateColsIfNotMerged(db.DefaultContext, "status") | |||
err := pr.UpdateColsIfNotMerged(ctx, "status") | |||
if err != nil { | |||
log.Error("AddToTaskQueue(%-v).UpdateCols.(add to queue): %v", pr, err) | |||
return | |||
@@ -369,14 +369,14 @@ func testPR(id int64) { | |||
} | |||
// CheckPRsForBaseBranch check all pulls with baseBrannch | |||
func CheckPRsForBaseBranch(baseRepo *repo_model.Repository, baseBranchName string) error { | |||
prs, err := issues_model.GetUnmergedPullRequestsByBaseInfo(baseRepo.ID, baseBranchName) | |||
func CheckPRsForBaseBranch(ctx context.Context, baseRepo *repo_model.Repository, baseBranchName string) error { | |||
prs, err := issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, baseRepo.ID, baseBranchName) | |||
if err != nil { | |||
return err | |||
} | |||
for _, pr := range prs { | |||
AddToTaskQueue(pr) | |||
AddToTaskQueue(ctx, pr) | |||
} | |||
return nil |
@@ -10,6 +10,7 @@ import ( | |||
"testing" | |||
"time" | |||
"code.gitea.io/gitea/models/db" | |||
issues_model "code.gitea.io/gitea/models/issues" | |||
"code.gitea.io/gitea/models/unittest" | |||
"code.gitea.io/gitea/modules/queue" | |||
@@ -36,7 +37,7 @@ func TestPullRequest_AddToTaskQueue(t *testing.T) { | |||
assert.NoError(t, err) | |||
pr := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 2}) | |||
AddToTaskQueue(pr) | |||
AddToTaskQueue(db.DefaultContext, pr) | |||
assert.Eventually(t, func() bool { | |||
pr = unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 2}) |
@@ -24,7 +24,6 @@ import ( | |||
user_model "code.gitea.io/gitea/models/user" | |||
"code.gitea.io/gitea/modules/cache" | |||
"code.gitea.io/gitea/modules/git" | |||
"code.gitea.io/gitea/modules/graceful" | |||
"code.gitea.io/gitea/modules/log" | |||
"code.gitea.io/gitea/modules/notification" | |||
"code.gitea.io/gitea/modules/references" | |||
@@ -182,10 +181,7 @@ func Merge(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.U | |||
go AddTestPullRequestTask(doer, pr.BaseRepo.ID, pr.BaseBranch, false, "", "") | |||
}() | |||
// Run the merge in the hammer context to prevent cancellation | |||
hammerCtx := graceful.GetManager().HammerContext() | |||
pr.MergedCommitID, err = doMergeAndPush(hammerCtx, pr, doer, mergeStyle, expectedHeadCommitID, message) | |||
pr.MergedCommitID, err = doMergeAndPush(ctx, pr, doer, mergeStyle, expectedHeadCommitID, message) | |||
if err != nil { | |||
return err | |||
} | |||
@@ -194,47 +190,47 @@ func Merge(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.U | |||
pr.Merger = doer | |||
pr.MergerID = doer.ID | |||
if _, err := pr.SetMerged(hammerCtx); err != nil { | |||
if _, err := pr.SetMerged(ctx); err != nil { | |||
log.Error("SetMerged %-v: %v", pr, err) | |||
} | |||
if err := pr.LoadIssue(hammerCtx); err != nil { | |||
if err := pr.LoadIssue(ctx); err != nil { | |||
log.Error("LoadIssue %-v: %v", pr, err) | |||
} | |||
if err := pr.Issue.LoadRepo(hammerCtx); err != nil { | |||
if err := pr.Issue.LoadRepo(ctx); err != nil { | |||
log.Error("pr.Issue.LoadRepo %-v: %v", pr, err) | |||
} | |||
if err := pr.Issue.Repo.LoadOwner(hammerCtx); err != nil { | |||
if err := pr.Issue.Repo.LoadOwner(ctx); err != nil { | |||
log.Error("LoadOwner for %-v: %v", pr, err) | |||
} | |||
if wasAutoMerged { | |||
notification.NotifyAutoMergePullRequest(hammerCtx, doer, pr) | |||
notification.NotifyAutoMergePullRequest(ctx, doer, pr) | |||
} else { | |||
notification.NotifyMergePullRequest(hammerCtx, doer, pr) | |||
notification.NotifyMergePullRequest(ctx, doer, pr) | |||
} | |||
// Reset cached commit count | |||
cache.Remove(pr.Issue.Repo.GetCommitsCountCacheKey(pr.BaseBranch, true)) | |||
// Resolve cross references | |||
refs, err := pr.ResolveCrossReferences(hammerCtx) | |||
refs, err := pr.ResolveCrossReferences(ctx) | |||
if err != nil { | |||
log.Error("ResolveCrossReferences: %v", err) | |||
return nil | |||
} | |||
for _, ref := range refs { | |||
if err = ref.LoadIssue(hammerCtx); err != nil { | |||
if err = ref.LoadIssue(ctx); err != nil { | |||
return err | |||
} | |||
if err = ref.Issue.LoadRepo(hammerCtx); err != nil { | |||
if err = ref.Issue.LoadRepo(ctx); err != nil { | |||
return err | |||
} | |||
close := ref.RefAction == references.XRefActionCloses | |||
if close != ref.Issue.IsClosed { | |||
if err = issue_service.ChangeStatus(ref.Issue, doer, pr.MergedCommitID, close); err != nil { | |||
if err = issue_service.ChangeStatus(ctx, ref.Issue, doer, pr.MergedCommitID, close); err != nil { | |||
// Allow ErrDependenciesLeft | |||
if !issues_model.IsErrDependenciesLeft(err) { | |||
return err |
@@ -265,7 +265,7 @@ func AddTestPullRequestTask(doer *user_model.User, repoID int64, branch string, | |||
// TODO: graceful: AddTestPullRequestTask needs to become a queue! | |||
// GetUnmergedPullRequestsByHeadInfo() only return open and unmerged PR. | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(repoID, branch) | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(ctx, repoID, branch) | |||
if err != nil { | |||
log.Error("Find pull requests [head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err) | |||
return | |||
@@ -282,7 +282,7 @@ func AddTestPullRequestTask(doer *user_model.User, repoID int64, branch string, | |||
continue | |||
} | |||
AddToTaskQueue(pr) | |||
AddToTaskQueue(ctx, pr) | |||
comment, err := CreatePushPullComment(ctx, doer, pr, oldCommitID, newCommitID) | |||
if err == nil && comment != nil { | |||
notification.NotifyPullRequestPushCommits(ctx, doer, pr, comment) | |||
@@ -291,7 +291,7 @@ func AddTestPullRequestTask(doer *user_model.User, repoID int64, branch string, | |||
if isSync { | |||
requests := issues_model.PullRequestList(prs) | |||
if err = requests.LoadAttributes(); err != nil { | |||
if err = requests.LoadAttributes(ctx); err != nil { | |||
log.Error("PullRequestList.LoadAttributes: %v", err) | |||
} | |||
if invalidationErr := checkForInvalidation(ctx, requests, repoID, doer, branch); invalidationErr != nil { | |||
@@ -341,7 +341,7 @@ func AddTestPullRequestTask(doer *user_model.User, repoID int64, branch string, | |||
} | |||
log.Trace("AddTestPullRequestTask [base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch) | |||
prs, err = issues_model.GetUnmergedPullRequestsByBaseInfo(repoID, branch) | |||
prs, err = issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, repoID, branch) | |||
if err != nil { | |||
log.Error("Find pull requests [base_repo_id: %d, base_branch: %s]: %v", repoID, branch, err) | |||
return | |||
@@ -360,7 +360,7 @@ func AddTestPullRequestTask(doer *user_model.User, repoID int64, branch string, | |||
log.Error("UpdateCommitDivergence: %v", err) | |||
} | |||
} | |||
AddToTaskQueue(pr) | |||
AddToTaskQueue(ctx, pr) | |||
} | |||
}) | |||
} | |||
@@ -514,25 +514,25 @@ func (errs errlist) Error() string { | |||
} | |||
// CloseBranchPulls close all the pull requests who's head branch is the branch | |||
func CloseBranchPulls(doer *user_model.User, repoID int64, branch string) error { | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(repoID, branch) | |||
func CloseBranchPulls(ctx context.Context, doer *user_model.User, repoID int64, branch string) error { | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(ctx, repoID, branch) | |||
if err != nil { | |||
return err | |||
} | |||
prs2, err := issues_model.GetUnmergedPullRequestsByBaseInfo(repoID, branch) | |||
prs2, err := issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, repoID, branch) | |||
if err != nil { | |||
return err | |||
} | |||
prs = append(prs, prs2...) | |||
if err := issues_model.PullRequestList(prs).LoadAttributes(); err != nil { | |||
if err := issues_model.PullRequestList(prs).LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
var errs errlist | |||
for _, pr := range prs { | |||
if err = issue_service.ChangeStatus(pr.Issue, doer, "", true); err != nil && !issues_model.IsErrPullWasClosed(err) && !issues_model.IsErrDependenciesLeft(err) { | |||
if err = issue_service.ChangeStatus(ctx, pr.Issue, doer, "", true); err != nil && !issues_model.IsErrPullWasClosed(err) && !issues_model.IsErrDependenciesLeft(err) { | |||
errs = append(errs, err) | |||
} | |||
} | |||
@@ -551,12 +551,12 @@ func CloseRepoBranchesPulls(ctx context.Context, doer *user_model.User, repo *re | |||
var errs errlist | |||
for _, branch := range branches { | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(repo.ID, branch.Name) | |||
prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(ctx, repo.ID, branch.Name) | |||
if err != nil { | |||
return err | |||
} | |||
if err = issues_model.PullRequestList(prs).LoadAttributes(); err != nil { | |||
if err = issues_model.PullRequestList(prs).LoadAttributes(ctx); err != nil { | |||
return err | |||
} | |||
@@ -566,7 +566,7 @@ func CloseRepoBranchesPulls(ctx context.Context, doer *user_model.User, repo *re | |||
if pr.BaseRepoID == repo.ID { | |||
continue | |||
} | |||
if err = issue_service.ChangeStatus(pr.Issue, doer, "", true); err != nil && !issues_model.IsErrPullWasClosed(err) { | |||
if err = issue_service.ChangeStatus(ctx, pr.Issue, doer, "", true); err != nil && !issues_model.IsErrPullWasClosed(err) { | |||
errs = append(errs, err) | |||
} | |||
} |
@@ -222,7 +222,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error { | |||
commits := repo_module.GitToPushCommits(l) | |||
commits.HeadCommit = repo_module.CommitToPushCommit(newCommit) | |||
if err := issue_service.UpdateIssuesCommit(pusher, repo, commits.Commits, refName); err != nil { | |||
if err := issue_service.UpdateIssuesCommit(ctx, pusher, repo, commits.Commits, refName); err != nil { | |||
log.Error("updateIssuesCommit: %v", err) | |||
} | |||
@@ -269,12 +269,12 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error { | |||
} | |||
} else { | |||
notification.NotifyDeleteRef(ctx, pusher, repo, opts.RefFullName) | |||
if err = pull_service.CloseBranchPulls(pusher, repo.ID, branch); err != nil { | |||
if err = pull_service.CloseBranchPulls(ctx, pusher, repo.ID, branch); err != nil { | |||
// close all related pulls | |||
log.Error("close related pull request failed: %v", err) | |||
} | |||
if err := git_model.AddDeletedBranch(db.DefaultContext, repo.ID, branch, pusher.ID); err != nil { | |||
if err := git_model.AddDeletedBranch(ctx, repo.ID, branch, pusher.ID); err != nil { | |||
return fmt.Errorf("AddDeletedBranch %s:%s failed: %v", repo.FullName(), branch, err) | |||
} | |||
} |