Even more `db.DefaultContext` refactor (#27352)

Part of #27065

---------

Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: delvh <dev.lh@web.de>

8 files changed, 81 insertions, 81 deletions

diff --git a/models/organization/org.go b/models/organization/org.go
index 260571b4b2..07091194eb 100644
--- a/models/organization/org.go
+++ b/models/organization/org.go
@@ -96,23 +96,23 @@ func (Organization) TableName() string {
 }
 
 // IsOwnedBy returns true if given user is in the owner team.
-func (org *Organization) IsOwnedBy(uid int64) (bool, error) {
-	return IsOrganizationOwner(db.DefaultContext, org.ID, uid)
+func (org *Organization) IsOwnedBy(ctx context.Context, uid int64) (bool, error) {
+	return IsOrganizationOwner(ctx, org.ID, uid)
 }
 
 // IsOrgAdmin returns true if given user is in the owner team or an admin team.
-func (org *Organization) IsOrgAdmin(uid int64) (bool, error) {
-	return IsOrganizationAdmin(db.DefaultContext, org.ID, uid)
+func (org *Organization) IsOrgAdmin(ctx context.Context, uid int64) (bool, error) {
+	return IsOrganizationAdmin(ctx, org.ID, uid)
 }
 
 // IsOrgMember returns true if given user is member of organization.
-func (org *Organization) IsOrgMember(uid int64) (bool, error) {
-	return IsOrganizationMember(db.DefaultContext, org.ID, uid)
+func (org *Organization) IsOrgMember(ctx context.Context, uid int64) (bool, error) {
+	return IsOrganizationMember(ctx, org.ID, uid)
 }
 
 // CanCreateOrgRepo returns true if given user can create repo in organization
-func (org *Organization) CanCreateOrgRepo(uid int64) (bool, error) {
-	return CanCreateOrgRepo(db.DefaultContext, org.ID, uid)
+func (org *Organization) CanCreateOrgRepo(ctx context.Context, uid int64) (bool, error) {
+	return CanCreateOrgRepo(ctx, org.ID, uid)
 }
 
 // GetTeam returns named team of organization.
@@ -135,8 +135,8 @@ func FindOrgTeams(ctx context.Context, orgID int64) ([]*Team, error) {
 }
 
 // LoadTeams load teams if not loaded.
-func (org *Organization) LoadTeams() ([]*Team, error) {
-	return FindOrgTeams(db.DefaultContext, org.ID)
+func (org *Organization) LoadTeams(ctx context.Context) ([]*Team, error) {
+	return FindOrgTeams(ctx, org.ID)
 }
 
 // GetMembers returns all members of organization.
@@ -147,8 +147,8 @@ func (org *Organization) GetMembers(ctx context.Context) (user_model.UserList, m
 }
 
 // HasMemberWithUserID returns true if user with userID is part of the u organisation.
-func (org *Organization) HasMemberWithUserID(userID int64) bool {
-	return org.hasMemberWithUserID(db.DefaultContext, userID)
+func (org *Organization) HasMemberWithUserID(ctx context.Context, userID int64) bool {
+	return org.hasMemberWithUserID(ctx, userID)
 }
 
 func (org *Organization) hasMemberWithUserID(ctx context.Context, userID int64) bool {
@@ -199,8 +199,8 @@ type FindOrgMembersOpts struct {
 }
 
 // CountOrgMembers counts the organization's members
-func CountOrgMembers(opts *FindOrgMembersOpts) (int64, error) {
-	sess := db.GetEngine(db.DefaultContext).Where("org_id=?", opts.OrgID)
+func CountOrgMembers(ctx context.Context, opts *FindOrgMembersOpts) (int64, error) {
+	sess := db.GetEngine(ctx).Where("org_id=?", opts.OrgID)
 	if opts.PublicOnly {
 		sess.And("is_public = ?", true)
 	}
@@ -271,7 +271,7 @@ func (org *Organization) UnitPermission(ctx context.Context, doer *user_model.Us
 }
 
 // CreateOrganization creates record of a new organization.
-func CreateOrganization(org *Organization, owner *user_model.User) (err error) {
+func CreateOrganization(ctx context.Context, org *Organization, owner *user_model.User) (err error) {
 	if !owner.CanCreateOrganization() {
 		return ErrUserNotAllowedCreateOrg{}
 	}
@@ -280,7 +280,7 @@ func CreateOrganization(org *Organization, owner *user_model.User) (err error) {
 		return err
 	}
 
-	isExist, err := user_model.IsUserExist(db.DefaultContext, 0, org.Name)
+	isExist, err := user_model.IsUserExist(ctx, 0, org.Name)
 	if err != nil {
 		return err
 	} else if isExist {
@@ -300,7 +300,7 @@ func CreateOrganization(org *Organization, owner *user_model.User) (err error) {
 	org.NumMembers = 1
 	org.Type = user_model.UserTypeOrganization
 
-	ctx, committer, err := db.TxContext(db.DefaultContext)
+	ctx, committer, err := db.TxContext(ctx)
 	if err != nil {
 		return err
 	}
@@ -412,9 +412,9 @@ func DeleteOrganization(ctx context.Context, org *Organization) error {
 }
 
 // GetOrgUserMaxAuthorizeLevel returns highest authorize level of user in an organization
-func (org *Organization) GetOrgUserMaxAuthorizeLevel(uid int64) (perm.AccessMode, error) {
+func (org *Organization) GetOrgUserMaxAuthorizeLevel(ctx context.Context, uid int64) (perm.AccessMode, error) {
 	var authorize perm.AccessMode
-	_, err := db.GetEngine(db.DefaultContext).
+	_, err := db.GetEngine(ctx).
 		Select("max(team.authorize)").
 		Table("team").
 		Join("INNER", "team_user", "team_user.team_id = team.id").
@@ -468,9 +468,9 @@ func (opts FindOrgOptions) toConds() builder.Cond {
 }
 
 // FindOrgs returns a list of organizations according given conditions
-func FindOrgs(opts FindOrgOptions) ([]*Organization, error) {
+func FindOrgs(ctx context.Context, opts FindOrgOptions) ([]*Organization, error) {
 	orgs := make([]*Organization, 0, 10)
-	sess := db.GetEngine(db.DefaultContext).
+	sess := db.GetEngine(ctx).
 		Where(opts.toConds()).
 		Asc("`user`.name")
 	if opts.Page > 0 && opts.PageSize > 0 {
@@ -480,8 +480,8 @@ func FindOrgs(opts FindOrgOptions) ([]*Organization, error) {
 }
 
 // CountOrgs returns total count organizations according options
-func CountOrgs(opts FindOrgOptions) (int64, error) {
-	return db.GetEngine(db.DefaultContext).
+func CountOrgs(ctx context.Context, opts FindOrgOptions) (int64, error) {
+	return db.GetEngine(ctx).
 		Where(opts.toConds()).
 		Count(new(Organization))
 }
@@ -505,13 +505,13 @@ func HasOrgOrUserVisible(ctx context.Context, orgOrUser, user *user_model.User)
 }
 
 // HasOrgsVisible tells if the given user can see at least one of the orgs provided
-func HasOrgsVisible(orgs []*Organization, user *user_model.User) bool {
+func HasOrgsVisible(ctx context.Context, orgs []*Organization, user *user_model.User) bool {
 	if len(orgs) == 0 {
 		return false
 	}
 
 	for _, org := range orgs {
-		if HasOrgOrUserVisible(db.DefaultContext, org.AsUser(), user) {
+		if HasOrgOrUserVisible(ctx, org.AsUser(), user) {
 			return true
 		}
 	}
@@ -550,9 +550,9 @@ func GetOrgUsersByOrgID(ctx context.Context, opts *FindOrgMembersOpts) ([]*OrgUs
 }
 
 // ChangeOrgUserStatus changes public or private membership status.
-func ChangeOrgUserStatus(orgID, uid int64, public bool) error {
+func ChangeOrgUserStatus(ctx context.Context, orgID, uid int64, public bool) error {
 	ou := new(OrgUser)
-	has, err := db.GetEngine(db.DefaultContext).
+	has, err := db.GetEngine(ctx).
 		Where("uid=?", uid).
 		And("org_id=?", orgID).
 		Get(ou)
@@ -563,18 +563,18 @@ func ChangeOrgUserStatus(orgID, uid int64, public bool) error {
 	}
 
 	ou.IsPublic = public
-	_, err = db.GetEngine(db.DefaultContext).ID(ou.ID).Cols("is_public").Update(ou)
+	_, err = db.GetEngine(ctx).ID(ou.ID).Cols("is_public").Update(ou)
 	return err
 }
 
 // AddOrgUser adds new user to given organization.
-func AddOrgUser(orgID, uid int64) error {
-	isAlreadyMember, err := IsOrganizationMember(db.DefaultContext, orgID, uid)
+func AddOrgUser(ctx context.Context, orgID, uid int64) error {
+	isAlreadyMember, err := IsOrganizationMember(ctx, orgID, uid)
 	if err != nil || isAlreadyMember {
 		return err
 	}
 
-	ctx, committer, err := db.TxContext(db.DefaultContext)
+	ctx, committer, err := db.TxContext(ctx)
 	if err != nil {
 		return err
 	}
@@ -669,19 +669,19 @@ func (org *Organization) getUserTeamIDs(ctx context.Context, userID int64) ([]in
 }
 
 // TeamsWithAccessToRepo returns all teams that have given access level to the repository.
-func (org *Organization) TeamsWithAccessToRepo(repoID int64, mode perm.AccessMode) ([]*Team, error) {
-	return GetTeamsWithAccessToRepo(db.DefaultContext, org.ID, repoID, mode)
+func (org *Organization) TeamsWithAccessToRepo(ctx context.Context, repoID int64, mode perm.AccessMode) ([]*Team, error) {
+	return GetTeamsWithAccessToRepo(ctx, org.ID, repoID, mode)
 }
 
 // GetUserTeamIDs returns of all team IDs of the organization that user is member of.
-func (org *Organization) GetUserTeamIDs(userID int64) ([]int64, error) {
-	return org.getUserTeamIDs(db.DefaultContext, userID)
+func (org *Organization) GetUserTeamIDs(ctx context.Context, userID int64) ([]int64, error) {
+	return org.getUserTeamIDs(ctx, userID)
 }
 
 // GetUserTeams returns all teams that belong to user,
 // and that the user has joined.
-func (org *Organization) GetUserTeams(userID int64) ([]*Team, error) {
-	return org.getUserTeams(db.DefaultContext, userID)
+func (org *Organization) GetUserTeams(ctx context.Context, userID int64) ([]*Team, error) {
+	return org.getUserTeams(ctx, userID)
 }
 
 // AccessibleReposEnvironment operations involving the repositories that are
@@ -733,11 +733,11 @@ func AccessibleReposEnv(ctx context.Context, org *Organization, userID int64) (A
 
 // AccessibleTeamReposEnv an AccessibleReposEnvironment for the repositories in `org`
 // that are accessible to the specified team.
-func (org *Organization) AccessibleTeamReposEnv(team *Team) AccessibleReposEnvironment {
+func (org *Organization) AccessibleTeamReposEnv(ctx context.Context, team *Team) AccessibleReposEnvironment {
 	return &accessibleReposEnv{
 		org:     org,
 		team:    team,
-		ctx:     db.DefaultContext,
+		ctx:     ctx,
 		orderBy: db.SearchOrderByRecentUpdated,
 	}
 }
diff --git a/models/organization/org_test.go b/models/organization/org_test.go
index b5dff9ec01..aa72fc467e 100644
--- a/models/organization/org_test.go
+++ b/models/organization/org_test.go
@@ -31,7 +31,7 @@ func TestUser_IsOwnedBy(t *testing.T) {
 		{2, 3, false},
 	} {
 		org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: testCase.OrgID})
-		isOwner, err := org.IsOwnedBy(testCase.UserID)
+		isOwner, err := org.IsOwnedBy(db.DefaultContext, testCase.UserID)
 		assert.NoError(t, err)
 		assert.Equal(t, testCase.ExpectedOwner, isOwner)
 	}
@@ -52,7 +52,7 @@ func TestUser_IsOrgMember(t *testing.T) {
 		{2, 3, false},
 	} {
 		org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: testCase.OrgID})
-		isMember, err := org.IsOrgMember(testCase.UserID)
+		isMember, err := org.IsOrgMember(db.DefaultContext, testCase.UserID)
 		assert.NoError(t, err)
 		assert.Equal(t, testCase.ExpectedMember, isMember)
 	}
@@ -89,7 +89,7 @@ func TestUser_GetOwnerTeam(t *testing.T) {
 func TestUser_GetTeams(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
-	teams, err := org.LoadTeams()
+	teams, err := org.LoadTeams(db.DefaultContext)
 	assert.NoError(t, err)
 	if assert.Len(t, teams, 5) {
 		assert.Equal(t, int64(1), teams[0].ID)
@@ -131,7 +131,7 @@ func TestCountOrganizations(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	expected, err := db.GetEngine(db.DefaultContext).Where("type=?", user_model.UserTypeOrganization).Count(&organization.Organization{})
 	assert.NoError(t, err)
-	cnt, err := organization.CountOrgs(organization.FindOrgOptions{IncludePrivate: true})
+	cnt, err := organization.CountOrgs(db.DefaultContext, organization.FindOrgOptions{IncludePrivate: true})
 	assert.NoError(t, err)
 	assert.Equal(t, expected, cnt)
 }
@@ -168,7 +168,7 @@ func TestIsOrganizationMember(t *testing.T) {
 func TestIsPublicMembership(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	test := func(orgID, userID int64, expected bool) {
-		isMember, err := organization.IsPublicMembership(orgID, userID)
+		isMember, err := organization.IsPublicMembership(db.DefaultContext, orgID, userID)
 		assert.NoError(t, err)
 		assert.EqualValues(t, expected, isMember)
 	}
@@ -183,7 +183,7 @@ func TestIsPublicMembership(t *testing.T) {
 func TestFindOrgs(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	orgs, err := organization.FindOrgs(organization.FindOrgOptions{
+	orgs, err := organization.FindOrgs(db.DefaultContext, organization.FindOrgOptions{
 		UserID:         4,
 		IncludePrivate: true,
 	})
@@ -192,14 +192,14 @@ func TestFindOrgs(t *testing.T) {
 		assert.EqualValues(t, 3, orgs[0].ID)
 	}
 
-	orgs, err = organization.FindOrgs(organization.FindOrgOptions{
+	orgs, err = organization.FindOrgs(db.DefaultContext, organization.FindOrgOptions{
 		UserID:         4,
 		IncludePrivate: false,
 	})
 	assert.NoError(t, err)
 	assert.Len(t, orgs, 0)
 
-	total, err := organization.CountOrgs(organization.FindOrgOptions{
+	total, err := organization.CountOrgs(db.DefaultContext, organization.FindOrgOptions{
 		UserID:         4,
 		IncludePrivate: true,
 	})
@@ -250,7 +250,7 @@ func TestChangeOrgUserStatus(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
 	testSuccess := func(orgID, userID int64, public bool) {
-		assert.NoError(t, organization.ChangeOrgUserStatus(orgID, userID, public))
+		assert.NoError(t, organization.ChangeOrgUserStatus(db.DefaultContext, orgID, userID, public))
 		orgUser := unittest.AssertExistsAndLoadBean(t, &organization.OrgUser{OrgID: orgID, UID: userID})
 		assert.Equal(t, public, orgUser.IsPublic)
 	}
@@ -258,14 +258,14 @@ func TestChangeOrgUserStatus(t *testing.T) {
 	testSuccess(3, 2, false)
 	testSuccess(3, 2, false)
 	testSuccess(3, 4, true)
-	assert.NoError(t, organization.ChangeOrgUserStatus(unittest.NonexistentID, unittest.NonexistentID, true))
+	assert.NoError(t, organization.ChangeOrgUserStatus(db.DefaultContext, unittest.NonexistentID, unittest.NonexistentID, true))
 }
 
 func TestUser_GetUserTeamIDs(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
 	testSuccess := func(userID int64, expected []int64) {
-		teamIDs, err := org.GetUserTeamIDs(userID)
+		teamIDs, err := org.GetUserTeamIDs(db.DefaultContext, userID)
 		assert.NoError(t, err)
 		assert.Equal(t, expected, teamIDs)
 	}
@@ -352,7 +352,7 @@ func TestHasOrgVisibleTypePublic(t *testing.T) {
 	}
 
 	unittest.AssertNotExistsBean(t, &user_model.User{Name: org.Name, Type: user_model.UserTypeOrganization})
-	assert.NoError(t, organization.CreateOrganization(org, owner))
+	assert.NoError(t, organization.CreateOrganization(db.DefaultContext, org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
 		&organization.Organization{Name: org.Name, Type: user_model.UserTypeOrganization})
 	test1 := organization.HasOrgOrUserVisible(db.DefaultContext, org.AsUser(), owner)
@@ -375,7 +375,7 @@ func TestHasOrgVisibleTypeLimited(t *testing.T) {
 	}
 
 	unittest.AssertNotExistsBean(t, &user_model.User{Name: org.Name, Type: user_model.UserTypeOrganization})
-	assert.NoError(t, organization.CreateOrganization(org, owner))
+	assert.NoError(t, organization.CreateOrganization(db.DefaultContext, org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
 		&organization.Organization{Name: org.Name, Type: user_model.UserTypeOrganization})
 	test1 := organization.HasOrgOrUserVisible(db.DefaultContext, org.AsUser(), owner)
@@ -398,7 +398,7 @@ func TestHasOrgVisibleTypePrivate(t *testing.T) {
 	}
 
 	unittest.AssertNotExistsBean(t, &user_model.User{Name: org.Name, Type: user_model.UserTypeOrganization})
-	assert.NoError(t, organization.CreateOrganization(org, owner))
+	assert.NoError(t, organization.CreateOrganization(db.DefaultContext, org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
 		&organization.Organization{Name: org.Name, Type: user_model.UserTypeOrganization})
 	test1 := organization.HasOrgOrUserVisible(db.DefaultContext, org.AsUser(), owner)
@@ -461,7 +461,7 @@ func TestCreateOrganization(t *testing.T) {
 	}
 
 	unittest.AssertNotExistsBean(t, &user_model.User{Name: newOrgName, Type: user_model.UserTypeOrganization})
-	assert.NoError(t, organization.CreateOrganization(org, owner))
+	assert.NoError(t, organization.CreateOrganization(db.DefaultContext, org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
 		&organization.Organization{Name: newOrgName, Type: user_model.UserTypeOrganization})
 	ownerTeam := unittest.AssertExistsAndLoadBean(t,
@@ -481,7 +481,7 @@ func TestCreateOrganization2(t *testing.T) {
 	}
 
 	unittest.AssertNotExistsBean(t, &organization.Organization{Name: newOrgName, Type: user_model.UserTypeOrganization})
-	err := organization.CreateOrganization(org, owner)
+	err := organization.CreateOrganization(db.DefaultContext, org, owner)
 	assert.Error(t, err)
 	assert.True(t, organization.IsErrUserNotAllowedCreateOrg(err))
 	unittest.AssertNotExistsBean(t, &organization.Organization{Name: newOrgName, Type: user_model.UserTypeOrganization})
@@ -495,7 +495,7 @@ func TestCreateOrganization3(t *testing.T) {
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 	org := &organization.Organization{Name: "org3"}                       // should already exist
 	unittest.AssertExistsAndLoadBean(t, &user_model.User{Name: org.Name}) // sanity check
-	err := organization.CreateOrganization(org, owner)
+	err := organization.CreateOrganization(db.DefaultContext, org, owner)
 	assert.Error(t, err)
 	assert.True(t, user_model.IsErrUserAlreadyExist(err))
 	unittest.CheckConsistencyFor(t, &user_model.User{}, &organization.Team{})
@@ -506,7 +506,7 @@ func TestCreateOrganization4(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-	err := organization.CreateOrganization(&organization.Organization{Name: "assets"}, owner)
+	err := organization.CreateOrganization(db.DefaultContext, &organization.Organization{Name: "assets"}, owner)
 	assert.Error(t, err)
 	assert.True(t, db.IsErrNameReserved(err))
 	unittest.CheckConsistencyFor(t, &organization.Organization{}, &organization.Team{})
diff --git a/models/organization/org_user.go b/models/organization/org_user.go
index d0598ab5d1..5fe3a178d2 100644
--- a/models/organization/org_user.go
+++ b/models/organization/org_user.go
@@ -78,8 +78,8 @@ func IsOrganizationMember(ctx context.Context, orgID, uid int64) (bool, error) {
 }
 
 // IsPublicMembership returns true if the given user's membership of given org is public.
-func IsPublicMembership(orgID, uid int64) (bool, error) {
-	return db.GetEngine(db.DefaultContext).
+func IsPublicMembership(ctx context.Context, orgID, uid int64) (bool, error) {
+	return db.GetEngine(ctx).
 		Where("uid=?", uid).
 		And("org_id=?", orgID).
 		And("is_public=?", true).
@@ -98,12 +98,12 @@ func CanCreateOrgRepo(ctx context.Context, orgID, uid int64) (bool, error) {
 }
 
 // IsUserOrgOwner returns true if user is in the owner team of given organization.
-func IsUserOrgOwner(users user_model.UserList, orgID int64) map[int64]bool {
+func IsUserOrgOwner(ctx context.Context, users user_model.UserList, orgID int64) map[int64]bool {
 	results := make(map[int64]bool, len(users))
 	for _, user := range users {
 		results[user.ID] = false // Set default to false
 	}
-	ownerMaps, err := loadOrganizationOwners(db.DefaultContext, users, orgID)
+	ownerMaps, err := loadOrganizationOwners(ctx, users, orgID)
 	if err == nil {
 		for _, owner := range ownerMaps {
 			results[owner.UID] = true
diff --git a/models/organization/org_user_test.go b/models/organization/org_user_test.go
index 1c3cf2798d..7924517f31 100644
--- a/models/organization/org_user_test.go
+++ b/models/organization/org_user_test.go
@@ -39,7 +39,7 @@ func TestUserIsPublicMember(t *testing.T) {
 func testUserIsPublicMember(t *testing.T, uid, orgID int64, expected bool) {
 	user, err := user_model.GetUserByID(db.DefaultContext, uid)
 	assert.NoError(t, err)
-	is, err := organization.IsPublicMembership(orgID, user.ID)
+	is, err := organization.IsPublicMembership(db.DefaultContext, orgID, user.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, expected, is)
 }
@@ -123,7 +123,7 @@ func testUserListIsUserOrgOwner(t *testing.T, orgID int64, expected map[int64]bo
 	assert.NoError(t, err)
 	members, _, err := org.GetMembers(db.DefaultContext)
 	assert.NoError(t, err)
-	assert.Equal(t, expected, organization.IsUserOrgOwner(members, orgID))
+	assert.Equal(t, expected, organization.IsUserOrgOwner(db.DefaultContext, members, orgID))
 }
 
 func TestAddOrgUser(t *testing.T) {
@@ -134,7 +134,7 @@ func TestAddOrgUser(t *testing.T) {
 		if !unittest.BeanExists(t, &organization.OrgUser{OrgID: orgID, UID: userID}) {
 			expectedNumMembers++
 		}
-		assert.NoError(t, organization.AddOrgUser(orgID, userID))
+		assert.NoError(t, organization.AddOrgUser(db.DefaultContext, orgID, userID))
 		ou := &organization.OrgUser{OrgID: orgID, UID: userID}
 		unittest.AssertExistsAndLoadBean(t, ou)
 		assert.Equal(t, isPublic, ou.IsPublic)
diff --git a/models/organization/team.go b/models/organization/team.go
index 3624fdc466..72afc67369 100644
--- a/models/organization/team.go
+++ b/models/organization/team.go
@@ -144,8 +144,8 @@ func (t *Team) IsOwnerTeam() bool {
 }
 
 // IsMember returns true if given user is a member of team.
-func (t *Team) IsMember(userID int64) bool {
-	isMember, err := IsTeamMember(db.DefaultContext, t.OrgID, t.ID, userID)
+func (t *Team) IsMember(ctx context.Context, userID int64) bool {
+	isMember, err := IsTeamMember(ctx, t.OrgID, t.ID, userID)
 	if err != nil {
 		log.Error("IsMember: %v", err)
 		return false
@@ -217,10 +217,10 @@ func GetTeam(ctx context.Context, orgID int64, name string) (*Team, error) {
 }
 
 // GetTeamIDsByNames returns a slice of team ids corresponds to names.
-func GetTeamIDsByNames(orgID int64, names []string, ignoreNonExistent bool) ([]int64, error) {
+func GetTeamIDsByNames(ctx context.Context, orgID int64, names []string, ignoreNonExistent bool) ([]int64, error) {
 	ids := make([]int64, 0, len(names))
 	for _, name := range names {
-		u, err := GetTeam(db.DefaultContext, orgID, name)
+		u, err := GetTeam(ctx, orgID, name)
 		if err != nil {
 			if ignoreNonExistent {
 				continue
@@ -251,13 +251,13 @@ func GetTeamByID(ctx context.Context, teamID int64) (*Team, error) {
 }
 
 // GetTeamNamesByID returns team's lower name from a list of team ids.
-func GetTeamNamesByID(teamIDs []int64) ([]string, error) {
+func GetTeamNamesByID(ctx context.Context, teamIDs []int64) ([]string, error) {
 	if len(teamIDs) == 0 {
 		return []string{}, nil
 	}
 
 	var teamNames []string
-	err := db.GetEngine(db.DefaultContext).Table("team").
+	err := db.GetEngine(ctx).Table("team").
 		Select("lower_name").
 		In("id", teamIDs).
 		Asc("name").
diff --git a/models/organization/team_test.go b/models/organization/team_test.go
index af69715ca9..23a6affe24 100644
--- a/models/organization/team_test.go
+++ b/models/organization/team_test.go
@@ -27,14 +27,14 @@ func TestTeam_IsMember(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
 	team := unittest.AssertExistsAndLoadBean(t, &organization.Team{ID: 1})
-	assert.True(t, team.IsMember(2))
-	assert.False(t, team.IsMember(4))
-	assert.False(t, team.IsMember(unittest.NonexistentID))
+	assert.True(t, team.IsMember(db.DefaultContext, 2))
+	assert.False(t, team.IsMember(db.DefaultContext, 4))
+	assert.False(t, team.IsMember(db.DefaultContext, unittest.NonexistentID))
 
 	team = unittest.AssertExistsAndLoadBean(t, &organization.Team{ID: 2})
-	assert.True(t, team.IsMember(2))
-	assert.True(t, team.IsMember(4))
-	assert.False(t, team.IsMember(unittest.NonexistentID))
+	assert.True(t, team.IsMember(db.DefaultContext, 2))
+	assert.True(t, team.IsMember(db.DefaultContext, 4))
+	assert.False(t, team.IsMember(db.DefaultContext, unittest.NonexistentID))
 }
 
 func TestTeam_GetRepositories(t *testing.T) {
@@ -188,7 +188,7 @@ func TestUsersInTeamsCount(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
 	test := func(teamIDs, userIDs []int64, expected int64) {
-		count, err := organization.UsersInTeamsCount(teamIDs, userIDs)
+		count, err := organization.UsersInTeamsCount(db.DefaultContext, teamIDs, userIDs)
 		assert.NoError(t, err)
 		assert.Equal(t, expected, count)
 	}
diff --git a/models/organization/team_unit.go b/models/organization/team_unit.go
index 7668ca7483..3087b70770 100644
--- a/models/organization/team_unit.go
+++ b/models/organization/team_unit.go
@@ -30,8 +30,8 @@ func getUnitsByTeamID(ctx context.Context, teamID int64) (units []*TeamUnit, err
 }
 
 // UpdateTeamUnits updates a teams's units
-func UpdateTeamUnits(team *Team, units []TeamUnit) (err error) {
-	ctx, committer, err := db.TxContext(db.DefaultContext)
+func UpdateTeamUnits(ctx context.Context, team *Team, units []TeamUnit) (err error) {
+	ctx, committer, err := db.TxContext(ctx)
 	if err != nil {
 		return err
 	}
diff --git a/models/organization/team_user.go b/models/organization/team_user.go
index 768dc24c50..ab767db200 100644
--- a/models/organization/team_user.go
+++ b/models/organization/team_user.go
@@ -78,9 +78,9 @@ func IsUserInTeams(ctx context.Context, userID int64, teamIDs []int64) (bool, er
 }
 
 // UsersInTeamsCount counts the number of users which are in userIDs and teamIDs
-func UsersInTeamsCount(userIDs, teamIDs []int64) (int64, error) {
+func UsersInTeamsCount(ctx context.Context, userIDs, teamIDs []int64) (int64, error) {
 	var ids []int64
-	if err := db.GetEngine(db.DefaultContext).In("uid", userIDs).In("team_id", teamIDs).
+	if err := db.GetEngine(ctx).In("uid", userIDs).In("team_id", teamIDs).
 		Table("team_user").
 		Cols("uid").GroupBy("uid").Find(&ids); err != nil {
 		return 0, err