Use a standalone struct name for Organization (#17632)

* Use a standalone struct name for Organization

* recover unnecessary change

* make the code readable

* Fix template failure

* Fix template failure

* Move HasMemberWithUserID to org

* Fix test

* Remove unnecessary user type check

* Fix test

Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>

10 files changed, 245 insertions, 166 deletions

diff --git a/models/access.go b/models/access.go
index 7bbc04bd45..500bcc1e19 100644
--- a/models/access.go
+++ b/models/access.go
@@ -254,11 +254,12 @@ func (repo *Repository) recalculateTeamAccesses(e db.Engine, ignTeamID int64) (e
 		return fmt.Errorf("refreshCollaboratorAccesses: %v", err)
 	}
 
-	if err = repo.Owner.loadTeams(e); err != nil {
+	teams, err := OrgFromUser(repo.Owner).loadTeams(e)
+	if err != nil {
 		return err
 	}
 
-	for _, t := range repo.Owner.Teams {
+	for _, t := range teams {
 		if t.ID == ignTeamID {
 			continue
 		}
diff --git a/models/action.go b/models/action.go
index 80ac3e16f8..d790cd6678 100644
--- a/models/action.go
+++ b/models/action.go
@@ -352,7 +352,7 @@ func activityQueryCondition(opts GetFeedsOptions) (builder.Cond, error) {
 	// check readable repositories by doer/actor
 	if opts.Actor == nil || !opts.Actor.IsAdmin {
 		if opts.RequestedUser.IsOrganization() {
-			env, err := opts.RequestedUser.AccessibleReposEnv(actorID)
+			env, err := OrgFromUser(opts.RequestedUser).AccessibleReposEnv(actorID)
 			if err != nil {
 				return nil, fmt.Errorf("AccessibleReposEnv: %v", err)
 			}
@@ -366,7 +366,7 @@ func activityQueryCondition(opts GetFeedsOptions) (builder.Cond, error) {
 	}
 
 	if opts.RequestedTeam != nil {
-		env := opts.RequestedUser.AccessibleTeamReposEnv(opts.RequestedTeam)
+		env := OrgFromUser(opts.RequestedUser).AccessibleTeamReposEnv(opts.RequestedTeam)
 		teamRepoIDs, err := env.RepoIDs(1, opts.RequestedUser.NumRepos)
 		if err != nil {
 			return nil, fmt.Errorf("GetTeamRepositories: %v", err)
diff --git a/models/org.go b/models/org.go
index e0b4d27245..c79af5c7bb 100644
--- a/models/org.go
+++ b/models/org.go
@@ -21,60 +21,109 @@ import (
 	"xorm.io/xorm"
 )
 
+// Organization represents an organization
+type Organization User
+
+// OrgFromUser converts user to organization
+func OrgFromUser(user *User) *Organization {
+	return (*Organization)(user)
+}
+
+// TableName represents the real table name of Organization
+func (Organization) TableName() string {
+	return "user"
+}
+
 // IsOwnedBy returns true if given user is in the owner team.
-func (org *User) IsOwnedBy(uid int64) (bool, error) {
+func (org *Organization) IsOwnedBy(uid int64) (bool, error) {
 	return IsOrganizationOwner(org.ID, uid)
 }
 
 // IsOrgMember returns true if given user is member of organization.
-func (org *User) IsOrgMember(uid int64) (bool, error) {
+func (org *Organization) IsOrgMember(uid int64) (bool, error) {
 	return IsOrganizationMember(org.ID, uid)
 }
 
 // CanCreateOrgRepo returns true if given user can create repo in organization
-func (org *User) CanCreateOrgRepo(uid int64) (bool, error) {
+func (org *Organization) CanCreateOrgRepo(uid int64) (bool, error) {
 	return CanCreateOrgRepo(org.ID, uid)
 }
 
-func (org *User) getTeam(e db.Engine, name string) (*Team, error) {
+func (org *Organization) getTeam(e db.Engine, name string) (*Team, error) {
 	return getTeam(e, org.ID, name)
 }
 
 // GetTeam returns named team of organization.
-func (org *User) GetTeam(name string) (*Team, error) {
+func (org *Organization) GetTeam(name string) (*Team, error) {
 	return org.getTeam(db.GetEngine(db.DefaultContext), name)
 }
 
-func (org *User) getOwnerTeam(e db.Engine) (*Team, error) {
+func (org *Organization) getOwnerTeam(e db.Engine) (*Team, error) {
 	return org.getTeam(e, ownerTeamName)
 }
 
 // GetOwnerTeam returns owner team of organization.
-func (org *User) GetOwnerTeam() (*Team, error) {
+func (org *Organization) GetOwnerTeam() (*Team, error) {
 	return org.getOwnerTeam(db.GetEngine(db.DefaultContext))
 }
 
-func (org *User) loadTeams(e db.Engine) error {
-	if org.Teams != nil {
-		return nil
-	}
-	return e.
+func (org *Organization) loadTeams(e db.Engine) ([]*Team, error) {
+	var teams []*Team
+	return teams, e.
 		Where("org_id=?", org.ID).
 		OrderBy("CASE WHEN name LIKE '" + ownerTeamName + "' THEN '' ELSE name END").
-		Find(&org.Teams)
+		Find(&teams)
 }
 
 // LoadTeams load teams if not loaded.
-func (org *User) LoadTeams() error {
+func (org *Organization) LoadTeams() ([]*Team, error) {
 	return org.loadTeams(db.GetEngine(db.DefaultContext))
 }
 
 // GetMembers returns all members of organization.
-func (org *User) GetMembers() (err error) {
-	org.Members, org.MembersIsPublic, err = FindOrgMembers(&FindOrgMembersOpts{
+func (org *Organization) GetMembers() (UserList, map[int64]bool, error) {
+	return FindOrgMembers(&FindOrgMembersOpts{
 		OrgID: org.ID,
 	})
-	return
+}
+
+// HasMemberWithUserID returns true if user with userID is part of the u organisation.
+func (org *Organization) HasMemberWithUserID(userID int64) bool {
+	return org.hasMemberWithUserID(db.GetEngine(db.DefaultContext), userID)
+}
+
+func (org *Organization) hasMemberWithUserID(e db.Engine, userID int64) bool {
+	isMember, err := isOrganizationMember(e, org.ID, userID)
+	if err != nil {
+		log.Error("IsOrganizationMember: %v", err)
+		return false
+	}
+	return isMember
+}
+
+// AvatarLink returns the full avatar link with http host
+func (org *Organization) AvatarLink() string {
+	return org.AsUser().AvatarLink()
+}
+
+// HTMLURL returns the organization's full link.
+func (org *Organization) HTMLURL() string {
+	return org.AsUser().HTMLURL()
+}
+
+// OrganisationLink returns the organization sub page link.
+func (org *Organization) OrganisationLink() string {
+	return org.AsUser().OrganisationLink()
+}
+
+// ShortName ellipses username to length
+func (org *Organization) ShortName(length int) string {
+	return org.AsUser().ShortName(length)
+}
+
+// HomeLink returns the user or organization home page link.
+func (org *Organization) HomeLink() string {
+	return org.AsUser().HomeLink()
 }
 
 // FindOrgMembersOpts represensts find org members conditions
@@ -115,26 +164,42 @@ func FindOrgMembers(opts *FindOrgMembersOpts) (UserList, map[int64]bool, error)
 }
 
 // AddMember adds new member to organization.
-func (org *User) AddMember(uid int64) error {
+func (org *Organization) AddMember(uid int64) error {
 	return AddOrgUser(org.ID, uid)
 }
 
 // RemoveMember removes member from organization.
-func (org *User) RemoveMember(uid int64) error {
+func (org *Organization) RemoveMember(uid int64) error {
 	return RemoveOrgUser(org.ID, uid)
 }
 
-func (org *User) removeOrgRepo(e db.Engine, repoID int64) error {
+func (org *Organization) removeOrgRepo(e db.Engine, repoID int64) error {
 	return removeOrgRepo(e, org.ID, repoID)
 }
 
 // RemoveOrgRepo removes all team-repository relations of organization.
-func (org *User) RemoveOrgRepo(repoID int64) error {
+func (org *Organization) RemoveOrgRepo(repoID int64) error {
 	return org.removeOrgRepo(db.GetEngine(db.DefaultContext), repoID)
 }
 
+// AsUser returns the org as user object
+func (org *Organization) AsUser() *User {
+	return (*User)(org)
+}
+
+// DisplayName returns full name if it's not empty,
+// returns username otherwise.
+func (org *Organization) DisplayName() string {
+	return org.AsUser().DisplayName()
+}
+
+// CustomAvatarRelativePath returns user custom avatar relative path.
+func (org *Organization) CustomAvatarRelativePath() string {
+	return org.Avatar
+}
+
 // CreateOrganization creates record of a new organization.
-func CreateOrganization(org, owner *User) (err error) {
+func CreateOrganization(org *Organization, owner *User) (err error) {
 	if !owner.CanCreateOrganization() {
 		return ErrUserNotAllowedCreateOrg{}
 	}
@@ -176,7 +241,7 @@ func CreateOrganization(org, owner *User) (err error) {
 	if err = db.Insert(ctx, org); err != nil {
 		return fmt.Errorf("insert organization: %v", err)
 	}
-	if err = org.generateRandomAvatar(db.GetEngine(ctx)); err != nil {
+	if err = org.AsUser().generateRandomAvatar(db.GetEngine(ctx)); err != nil {
 		return fmt.Errorf("generate random avatar: %v", err)
 	}
 
@@ -228,11 +293,11 @@ func CreateOrganization(org, owner *User) (err error) {
 }
 
 // GetOrgByName returns organization by given name.
-func GetOrgByName(name string) (*User, error) {
+func GetOrgByName(name string) (*Organization, error) {
 	if len(name) == 0 {
 		return nil, ErrOrgNotExist{0, name}
 	}
-	u := &User{
+	u := &Organization{
 		LowerName: strings.ToLower(name),
 		Type:      UserTypeOrganization,
 	}
@@ -249,12 +314,16 @@ func GetOrgByName(name string) (*User, error) {
 func CountOrganizations() int64 {
 	count, _ := db.GetEngine(db.DefaultContext).
 		Where("type=1").
-		Count(new(User))
+		Count(new(Organization))
 	return count
 }
 
 // DeleteOrganization deletes models associated to an organization.
-func DeleteOrganization(ctx context.Context, org *User) error {
+func DeleteOrganization(ctx context.Context, org *Organization) error {
+	if org.Type != UserTypeOrganization {
+		return fmt.Errorf("%s is a user not an organization", org.Name)
+	}
+
 	e := db.GetEngine(ctx)
 
 	if err := deleteBeans(e,
@@ -346,7 +415,7 @@ func CanCreateOrgRepo(orgID, uid int64) (bool, error) {
 }
 
 // GetOrgUserMaxAuthorizeLevel returns highest authorize level of user in an organization
-func (org *User) GetOrgUserMaxAuthorizeLevel(uid int64) (AccessMode, error) {
+func (org *Organization) GetOrgUserMaxAuthorizeLevel(uid int64) (AccessMode, error) {
 	var authorize AccessMode
 	_, err := db.GetEngine(db.DefaultContext).
 		Select("max(team.authorize)").
@@ -372,8 +441,8 @@ func getUsersWhoCanCreateOrgRepo(e db.Engine, orgID int64) ([]*User, error) {
 		And("team_user.org_id = ?", orgID).Asc("`user`.name").Find(&users)
 }
 
-func getOrgsByUserID(sess *xorm.Session, userID int64, showAll bool) ([]*User, error) {
-	orgs := make([]*User, 0, 10)
+func getOrgsByUserID(sess *xorm.Session, userID int64, showAll bool) ([]*Organization, error) {
+	orgs := make([]*Organization, 0, 10)
 	if !showAll {
 		sess.And("`org_user`.is_public=?", true)
 	}
@@ -386,14 +455,14 @@ func getOrgsByUserID(sess *xorm.Session, userID int64, showAll bool) ([]*User, e
 
 // GetOrgsByUserID returns a list of organizations that the given user ID
 // has joined.
-func GetOrgsByUserID(userID int64, showAll bool) ([]*User, error) {
+func GetOrgsByUserID(userID int64, showAll bool) ([]*Organization, error) {
 	sess := db.NewSession(db.DefaultContext)
 	defer sess.Close()
 	return getOrgsByUserID(sess, userID, showAll)
 }
 
 // MinimalOrg represents a simple orgnization with only needed columns
-type MinimalOrg = User
+type MinimalOrg = Organization
 
 // GetUserOrgsList returns one user's all orgs list
 func GetUserOrgsList(user *User) ([]*MinimalOrg, error) {
@@ -434,8 +503,8 @@ func GetUserOrgsList(user *User) ([]*MinimalOrg, error) {
 		GroupBy(groupByStr)
 
 	type OrgCount struct {
-		User     `xorm:"extends"`
-		OrgCount int
+		Organization `xorm:"extends"`
+		OrgCount     int
 	}
 
 	orgCounts := make([]*OrgCount, 0, 10)
@@ -448,8 +517,8 @@ func GetUserOrgsList(user *User) ([]*MinimalOrg, error) {
 
 	orgs := make([]*MinimalOrg, len(orgCounts))
 	for i, orgCount := range orgCounts {
-		orgCount.User.NumRepos = orgCount.OrgCount
-		orgs[i] = &orgCount.User
+		orgCount.Organization.NumRepos = orgCount.OrgCount
+		orgs[i] = &orgCount.Organization
 	}
 
 	return orgs, nil
@@ -481,20 +550,20 @@ func hasOrgOrUserVisible(e db.Engine, orgOrUser, user *User) bool {
 		return true
 	}
 
-	if (orgOrUser.Visibility == structs.VisibleTypePrivate || user.IsRestricted) && !orgOrUser.hasMemberWithUserID(e, user.ID) {
+	if (orgOrUser.Visibility == structs.VisibleTypePrivate || user.IsRestricted) && !OrgFromUser(orgOrUser).hasMemberWithUserID(e, user.ID) {
 		return false
 	}
 	return true
 }
 
 // HasOrgsVisible tells if the given user can see at least one of the orgs provided
-func HasOrgsVisible(orgs []*User, user *User) bool {
+func HasOrgsVisible(orgs []*Organization, user *User) bool {
 	if len(orgs) == 0 {
 		return false
 	}
 
 	for _, org := range orgs {
-		if HasOrgOrUserVisible(org, user) {
+		if HasOrgOrUserVisible(org.AsUser(), user) {
 			return true
 		}
 	}
@@ -622,9 +691,28 @@ func AddOrgUser(orgID, uid int64) error {
 	return sess.Commit()
 }
 
-func removeOrgUser(sess *xorm.Session, orgID, userID int64) error {
+// GetOrgByIDCtx returns the user object by given ID if exists.
+func GetOrgByIDCtx(ctx context.Context, id int64) (*Organization, error) {
+	u := new(Organization)
+	has, err := db.GetEngine(ctx).ID(id).Get(u)
+	if err != nil {
+		return nil, err
+	} else if !has {
+		return nil, ErrUserNotExist{id, "", 0}
+	}
+	return u, nil
+}
+
+// GetOrgByID returns the user object by given ID if exists.
+func GetOrgByID(id int64) (*Organization, error) {
+	return GetOrgByIDCtx(db.DefaultContext, id)
+}
+
+func removeOrgUser(ctx context.Context, orgID, userID int64) error {
 	ou := new(OrgUser)
 
+	sess := db.GetEngine(ctx)
+
 	has, err := sess.
 		Where("uid=?", userID).
 		And("org_id=?", orgID).
@@ -635,7 +723,7 @@ func removeOrgUser(sess *xorm.Session, orgID, userID int64) error {
 		return nil
 	}
 
-	org, err := getUserByID(sess, orgID)
+	org, err := GetOrgByIDCtx(ctx, orgID)
 	if err != nil {
 		return fmt.Errorf("GetUserByID [%d]: %v", orgID, err)
 	}
@@ -694,7 +782,7 @@ func removeOrgUser(sess *xorm.Session, orgID, userID int64) error {
 		return err
 	}
 	for _, t := range teams {
-		if err = removeTeamMember(sess, t, userID); err != nil {
+		if err = removeTeamMember(ctx, t, userID); err != nil {
 			return err
 		}
 	}
@@ -704,15 +792,15 @@ func removeOrgUser(sess *xorm.Session, orgID, userID int64) error {
 
 // RemoveOrgUser removes user from given organization.
 func RemoveOrgUser(orgID, userID int64) error {
-	sess := db.NewSession(db.DefaultContext)
-	defer sess.Close()
-	if err := sess.Begin(); err != nil {
+	ctx, committer, err := db.TxContext()
+	if err != nil {
 		return err
 	}
-	if err := removeOrgUser(sess, orgID, userID); err != nil {
+	defer committer.Close()
+	if err := removeOrgUser(ctx, orgID, userID); err != nil {
 		return err
 	}
-	return sess.Commit()
+	return committer.Commit()
 }
 
 func removeOrgRepo(e db.Engine, orgID, repoID int64) error {
@@ -741,7 +829,7 @@ func removeOrgRepo(e db.Engine, orgID, repoID int64) error {
 	return err
 }
 
-func (org *User) getUserTeams(e db.Engine, userID int64, cols ...string) ([]*Team, error) {
+func (org *Organization) getUserTeams(e db.Engine, userID int64, cols ...string) ([]*Team, error) {
 	teams := make([]*Team, 0, org.NumTeams)
 	return teams, e.
 		Where("`team_user`.org_id = ?", org.ID).
@@ -753,7 +841,7 @@ func (org *User) getUserTeams(e db.Engine, userID int64, cols ...string) ([]*Tea
 		Find(&teams)
 }
 
-func (org *User) getUserTeamIDs(e db.Engine, userID int64) ([]int64, error) {
+func (org *Organization) getUserTeamIDs(e db.Engine, userID int64) ([]int64, error) {
 	teamIDs := make([]int64, 0, org.NumTeams)
 	return teamIDs, e.
 		Table("team").
@@ -765,18 +853,18 @@ func (org *User) getUserTeamIDs(e db.Engine, userID int64) ([]int64, error) {
 }
 
 // TeamsWithAccessToRepo returns all teams that have given access level to the repository.
-func (org *User) TeamsWithAccessToRepo(repoID int64, mode AccessMode) ([]*Team, error) {
+func (org *Organization) TeamsWithAccessToRepo(repoID int64, mode AccessMode) ([]*Team, error) {
 	return GetTeamsWithAccessToRepo(org.ID, repoID, mode)
 }
 
 // GetUserTeamIDs returns of all team IDs of the organization that user is member of.
-func (org *User) GetUserTeamIDs(userID int64) ([]int64, error) {
+func (org *Organization) GetUserTeamIDs(userID int64) ([]int64, error) {
 	return org.getUserTeamIDs(db.GetEngine(db.DefaultContext), userID)
 }
 
 // GetUserTeams returns all teams that belong to user,
 // and that the user has joined.
-func (org *User) GetUserTeams(userID int64) ([]*Team, error) {
+func (org *Organization) GetUserTeams(userID int64) ([]*Team, error) {
 	return org.getUserTeams(db.GetEngine(db.DefaultContext), userID)
 }
 
@@ -792,7 +880,7 @@ type AccessibleReposEnvironment interface {
 }
 
 type accessibleReposEnv struct {
-	org     *User
+	org     *Organization
 	user    *User
 	team    *Team
 	teamIDs []int64
@@ -803,11 +891,11 @@ type accessibleReposEnv struct {
 
 // AccessibleReposEnv builds an AccessibleReposEnvironment for the repositories in `org`
 // that are accessible to the specified user.
-func (org *User) AccessibleReposEnv(userID int64) (AccessibleReposEnvironment, error) {
+func (org *Organization) AccessibleReposEnv(userID int64) (AccessibleReposEnvironment, error) {
 	return org.accessibleReposEnv(db.GetEngine(db.DefaultContext), userID)
 }
 
-func (org *User) accessibleReposEnv(e db.Engine, userID int64) (AccessibleReposEnvironment, error) {
+func (org *Organization) accessibleReposEnv(e db.Engine, userID int64) (AccessibleReposEnvironment, error) {
 	var user *User
 
 	if userID > 0 {
@@ -833,7 +921,7 @@ func (org *User) accessibleReposEnv(e db.Engine, userID int64) (AccessibleReposE
 
 // AccessibleTeamReposEnv an AccessibleReposEnvironment for the repositories in `org`
 // that are accessible to the specified team.
-func (org *User) AccessibleTeamReposEnv(team *Team) AccessibleReposEnvironment {
+func (org *Organization) AccessibleTeamReposEnv(team *Team) AccessibleReposEnvironment {
 	return &accessibleReposEnv{
 		org:     org,
 		team:    team,
diff --git a/models/org_team.go b/models/org_team.go
index 10178ec88a..e3ad23c111 100644
--- a/models/org_team.go
+++ b/models/org_team.go
@@ -6,6 +6,7 @@
 package models
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"sort"
@@ -17,7 +18,6 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"xorm.io/builder"
-	"xorm.io/xorm"
 )
 
 const ownerTeamName = "Owners"
@@ -872,7 +872,8 @@ func AddTeamMember(team *Team, userID int64) error {
 	return sess.Commit()
 }
 
-func removeTeamMember(e *xorm.Session, team *Team, userID int64) error {
+func removeTeamMember(ctx context.Context, team *Team, userID int64) error {
+	e := db.GetEngine(ctx)
 	isMember, err := isTeamMember(e, team.OrgID, team.ID, userID)
 	if err != nil || !isMember {
 		return err
@@ -926,7 +927,7 @@ func removeTeamMember(e *xorm.Session, team *Team, userID int64) error {
 	}); err != nil {
 		return err
 	} else if count == 0 {
-		return removeOrgUser(e, team.OrgID, userID)
+		return removeOrgUser(ctx, team.OrgID, userID)
 	}
 
 	return nil
@@ -934,15 +935,15 @@ func removeTeamMember(e *xorm.Session, team *Team, userID int64) error {
 
 // RemoveTeamMember removes member from given team of given organization.
 func RemoveTeamMember(team *Team, userID int64) error {
-	sess := db.NewSession(db.DefaultContext)
-	defer sess.Close()
-	if err := sess.Begin(); err != nil {
+	ctx, committer, err := db.TxContext()
+	if err != nil {
 		return err
 	}
-	if err := removeTeamMember(sess, team, userID); err != nil {
+	defer committer.Close()
+	if err := removeTeamMember(ctx, team, userID); err != nil {
 		return err
 	}
-	return sess.Commit()
+	return committer.Commit()
 }
 
 // IsUserInTeams returns if a user in some teams
diff --git a/models/org_test.go b/models/org_test.go
index 8580702a06..10ae877458 100644
--- a/models/org_test.go
+++ b/models/org_test.go
@@ -29,7 +29,7 @@ func TestUser_IsOwnedBy(t *testing.T) {
 		{2, 2, false}, // user2 is not an organization
 		{2, 3, false},
 	} {
-		org := unittest.AssertExistsAndLoadBean(t, &User{ID: testCase.OrgID}).(*User)
+		org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: testCase.OrgID}).(*Organization)
 		isOwner, err := org.IsOwnedBy(testCase.UserID)
 		assert.NoError(t, err)
 		assert.Equal(t, testCase.ExpectedOwner, isOwner)
@@ -50,7 +50,7 @@ func TestUser_IsOrgMember(t *testing.T) {
 		{2, 2, false}, // user2 is not an organization
 		{2, 3, false},
 	} {
-		org := unittest.AssertExistsAndLoadBean(t, &User{ID: testCase.OrgID}).(*User)
+		org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: testCase.OrgID}).(*Organization)
 		isMember, err := org.IsOrgMember(testCase.UserID)
 		assert.NoError(t, err)
 		assert.Equal(t, testCase.ExpectedMember, isMember)
@@ -59,7 +59,7 @@ func TestUser_IsOrgMember(t *testing.T) {
 
 func TestUser_GetTeam(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	team, err := org.GetTeam("team1")
 	assert.NoError(t, err)
 	assert.Equal(t, org.ID, team.OrgID)
@@ -68,56 +68,58 @@ func TestUser_GetTeam(t *testing.T) {
 	_, err = org.GetTeam("does not exist")
 	assert.True(t, IsErrTeamNotExist(err))
 
-	nonOrg := unittest.AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
+	nonOrg := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 2}).(*Organization)
 	_, err = nonOrg.GetTeam("team")
 	assert.True(t, IsErrTeamNotExist(err))
 }
 
 func TestUser_GetOwnerTeam(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	team, err := org.GetOwnerTeam()
 	assert.NoError(t, err)
 	assert.Equal(t, org.ID, team.OrgID)
 
-	nonOrg := unittest.AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
+	nonOrg := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 2}).(*Organization)
 	_, err = nonOrg.GetOwnerTeam()
 	assert.True(t, IsErrTeamNotExist(err))
 }
 
 func TestUser_GetTeams(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
-	assert.NoError(t, org.LoadTeams())
-	if assert.Len(t, org.Teams, 4) {
-		assert.Equal(t, int64(1), org.Teams[0].ID)
-		assert.Equal(t, int64(2), org.Teams[1].ID)
-		assert.Equal(t, int64(12), org.Teams[2].ID)
-		assert.Equal(t, int64(7), org.Teams[3].ID)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
+	teams, err := org.LoadTeams()
+	assert.NoError(t, err)
+	if assert.Len(t, teams, 4) {
+		assert.Equal(t, int64(1), teams[0].ID)
+		assert.Equal(t, int64(2), teams[1].ID)
+		assert.Equal(t, int64(12), teams[2].ID)
+		assert.Equal(t, int64(7), teams[3].ID)
 	}
 }
 
 func TestUser_GetMembers(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
-	assert.NoError(t, org.GetMembers())
-	if assert.Len(t, org.Members, 3) {
-		assert.Equal(t, int64(2), org.Members[0].ID)
-		assert.Equal(t, int64(28), org.Members[1].ID)
-		assert.Equal(t, int64(4), org.Members[2].ID)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
+	members, _, err := org.GetMembers()
+	assert.NoError(t, err)
+	if assert.Len(t, members, 3) {
+		assert.Equal(t, int64(2), members[0].ID)
+		assert.Equal(t, int64(28), members[1].ID)
+		assert.Equal(t, int64(4), members[2].ID)
 	}
 }
 
 func TestUser_AddMember(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 
 	// add a user that is not a member
 	unittest.AssertNotExistsBean(t, &OrgUser{UID: 5, OrgID: 3})
 	prevNumMembers := org.NumMembers
 	assert.NoError(t, org.AddMember(5))
 	unittest.AssertExistsAndLoadBean(t, &OrgUser{UID: 5, OrgID: 3})
-	org = unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org = unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	assert.Equal(t, prevNumMembers+1, org.NumMembers)
 
 	// add a user that is already a member
@@ -125,7 +127,7 @@ func TestUser_AddMember(t *testing.T) {
 	prevNumMembers = org.NumMembers
 	assert.NoError(t, org.AddMember(4))
 	unittest.AssertExistsAndLoadBean(t, &OrgUser{UID: 4, OrgID: 3})
-	org = unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org = unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	assert.Equal(t, prevNumMembers, org.NumMembers)
 
 	unittest.CheckConsistencyFor(t, &User{})
@@ -133,14 +135,14 @@ func TestUser_AddMember(t *testing.T) {
 
 func TestUser_RemoveMember(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 
 	// remove a user that is a member
 	unittest.AssertExistsAndLoadBean(t, &OrgUser{UID: 4, OrgID: 3})
 	prevNumMembers := org.NumMembers
 	assert.NoError(t, org.RemoveMember(4))
 	unittest.AssertNotExistsBean(t, &OrgUser{UID: 4, OrgID: 3})
-	org = unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org = unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	assert.Equal(t, prevNumMembers-1, org.NumMembers)
 
 	// remove a user that is not a member
@@ -148,7 +150,7 @@ func TestUser_RemoveMember(t *testing.T) {
 	prevNumMembers = org.NumMembers
 	assert.NoError(t, org.RemoveMember(5))
 	unittest.AssertNotExistsBean(t, &OrgUser{UID: 5, OrgID: 3})
-	org = unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org = unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	assert.Equal(t, prevNumMembers, org.NumMembers)
 
 	unittest.CheckConsistencyFor(t, &User{}, &Team{})
@@ -156,7 +158,7 @@ func TestUser_RemoveMember(t *testing.T) {
 
 func TestUser_RemoveOrgRepo(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	repo := unittest.AssertExistsAndLoadBean(t, &Repository{OwnerID: org.ID}).(*Repository)
 
 	// remove a repo that does belong to org
@@ -183,14 +185,14 @@ func TestCreateOrganization(t *testing.T) {
 
 	owner := unittest.AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
 	const newOrgName = "neworg"
-	org := &User{
+	org := &Organization{
 		Name: newOrgName,
 	}
 
 	unittest.AssertNotExistsBean(t, &User{Name: newOrgName, Type: UserTypeOrganization})
 	assert.NoError(t, CreateOrganization(org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
-		&User{Name: newOrgName, Type: UserTypeOrganization}).(*User)
+		&Organization{Name: newOrgName, Type: UserTypeOrganization}).(*Organization)
 	ownerTeam := unittest.AssertExistsAndLoadBean(t,
 		&Team{Name: ownerTeamName, OrgID: org.ID}).(*Team)
 	unittest.AssertExistsAndLoadBean(t, &TeamUser{UID: owner.ID, TeamID: ownerTeam.ID})
@@ -203,16 +205,16 @@ func TestCreateOrganization2(t *testing.T) {
 
 	owner := unittest.AssertExistsAndLoadBean(t, &User{ID: 5}).(*User)
 	const newOrgName = "neworg"
-	org := &User{
+	org := &Organization{
 		Name: newOrgName,
 	}
 
-	unittest.AssertNotExistsBean(t, &User{Name: newOrgName, Type: UserTypeOrganization})
+	unittest.AssertNotExistsBean(t, &Organization{Name: newOrgName, Type: UserTypeOrganization})
 	err := CreateOrganization(org, owner)
 	assert.Error(t, err)
 	assert.True(t, IsErrUserNotAllowedCreateOrg(err))
-	unittest.AssertNotExistsBean(t, &User{Name: newOrgName, Type: UserTypeOrganization})
-	unittest.CheckConsistencyFor(t, &User{}, &Team{})
+	unittest.AssertNotExistsBean(t, &Organization{Name: newOrgName, Type: UserTypeOrganization})
+	unittest.CheckConsistencyFor(t, &Organization{}, &Team{})
 }
 
 func TestCreateOrganization3(t *testing.T) {
@@ -220,7 +222,7 @@ func TestCreateOrganization3(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
 	owner := unittest.AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
-	org := &User{Name: "user3"}                                // should already exist
+	org := &Organization{Name: "user3"}                        // should already exist
 	unittest.AssertExistsAndLoadBean(t, &User{Name: org.Name}) // sanity check
 	err := CreateOrganization(org, owner)
 	assert.Error(t, err)
@@ -233,10 +235,10 @@ func TestCreateOrganization4(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
 	owner := unittest.AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
-	err := CreateOrganization(&User{Name: "assets"}, owner)
+	err := CreateOrganization(&Organization{Name: "assets"}, owner)
 	assert.Error(t, err)
 	assert.True(t, IsErrNameReserved(err))
-	unittest.CheckConsistencyFor(t, &User{}, &Team{})
+	unittest.CheckConsistencyFor(t, &Organization{}, &Team{})
 }
 
 func TestGetOrgByName(t *testing.T) {
@@ -478,7 +480,7 @@ func TestRemoveOrgUser(t *testing.T) {
 
 func TestUser_GetUserTeamIDs(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	testSuccess := func(userID int64, expected []int64) {
 		teamIDs, err := org.GetUserTeamIDs(userID)
 		assert.NoError(t, err)
@@ -491,7 +493,7 @@ func TestUser_GetUserTeamIDs(t *testing.T) {
 
 func TestAccessibleReposEnv_CountRepos(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	testSuccess := func(userID, expectedCount int64) {
 		env, err := org.AccessibleReposEnv(userID)
 		assert.NoError(t, err)
@@ -505,7 +507,7 @@ func TestAccessibleReposEnv_CountRepos(t *testing.T) {
 
 func TestAccessibleReposEnv_RepoIDs(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	testSuccess := func(userID, _, pageSize int64, expectedRepoIDs []int64) {
 		env, err := org.AccessibleReposEnv(userID)
 		assert.NoError(t, err)
@@ -519,7 +521,7 @@ func TestAccessibleReposEnv_RepoIDs(t *testing.T) {
 
 func TestAccessibleReposEnv_Repos(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	testSuccess := func(userID int64, expectedRepoIDs []int64) {
 		env, err := org.AccessibleReposEnv(userID)
 		assert.NoError(t, err)
@@ -538,7 +540,7 @@ func TestAccessibleReposEnv_Repos(t *testing.T) {
 
 func TestAccessibleReposEnv_MirrorRepos(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	org := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
+	org := unittest.AssertExistsAndLoadBean(t, &Organization{ID: 3}).(*Organization)
 	testSuccess := func(userID int64, expectedRepoIDs []int64) {
 		env, err := org.AccessibleReposEnv(userID)
 		assert.NoError(t, err)
@@ -561,7 +563,7 @@ func TestHasOrgVisibleTypePublic(t *testing.T) {
 	user3 := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
 
 	const newOrgName = "test-org-public"
-	org := &User{
+	org := &Organization{
 		Name:       newOrgName,
 		Visibility: structs.VisibleTypePublic,
 	}
@@ -569,10 +571,10 @@ func TestHasOrgVisibleTypePublic(t *testing.T) {
 	unittest.AssertNotExistsBean(t, &User{Name: org.Name, Type: UserTypeOrganization})
 	assert.NoError(t, CreateOrganization(org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
-		&User{Name: org.Name, Type: UserTypeOrganization}).(*User)
-	test1 := HasOrgOrUserVisible(org, owner)
-	test2 := HasOrgOrUserVisible(org, user3)
-	test3 := HasOrgOrUserVisible(org, nil)
+		&Organization{Name: org.Name, Type: UserTypeOrganization}).(*Organization)
+	test1 := HasOrgOrUserVisible(org.AsUser(), owner)
+	test2 := HasOrgOrUserVisible(org.AsUser(), user3)
+	test3 := HasOrgOrUserVisible(org.AsUser(), nil)
 	assert.True(t, test1) // owner of org
 	assert.True(t, test2) // user not a part of org
 	assert.True(t, test3) // logged out user
@@ -584,7 +586,7 @@ func TestHasOrgVisibleTypeLimited(t *testing.T) {
 	user3 := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
 
 	const newOrgName = "test-org-limited"
-	org := &User{
+	org := &Organization{
 		Name:       newOrgName,
 		Visibility: structs.VisibleTypeLimited,
 	}
@@ -592,10 +594,10 @@ func TestHasOrgVisibleTypeLimited(t *testing.T) {
 	unittest.AssertNotExistsBean(t, &User{Name: org.Name, Type: UserTypeOrganization})
 	assert.NoError(t, CreateOrganization(org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
-		&User{Name: org.Name, Type: UserTypeOrganization}).(*User)
-	test1 := HasOrgOrUserVisible(org, owner)
-	test2 := HasOrgOrUserVisible(org, user3)
-	test3 := HasOrgOrUserVisible(org, nil)
+		&Organization{Name: org.Name, Type: UserTypeOrganization}).(*Organization)
+	test1 := HasOrgOrUserVisible(org.AsUser(), owner)
+	test2 := HasOrgOrUserVisible(org.AsUser(), user3)
+	test3 := HasOrgOrUserVisible(org.AsUser(), nil)
 	assert.True(t, test1)  // owner of org
 	assert.True(t, test2)  // user not a part of org
 	assert.False(t, test3) // logged out user
@@ -607,7 +609,7 @@ func TestHasOrgVisibleTypePrivate(t *testing.T) {
 	user3 := unittest.AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)
 
 	const newOrgName = "test-org-private"
-	org := &User{
+	org := &Organization{
 		Name:       newOrgName,
 		Visibility: structs.VisibleTypePrivate,
 	}
@@ -615,10 +617,10 @@ func TestHasOrgVisibleTypePrivate(t *testing.T) {
 	unittest.AssertNotExistsBean(t, &User{Name: org.Name, Type: UserTypeOrganization})
 	assert.NoError(t, CreateOrganization(org, owner))
 	org = unittest.AssertExistsAndLoadBean(t,
-		&User{Name: org.Name, Type: UserTypeOrganization}).(*User)
-	test1 := HasOrgOrUserVisible(org, owner)
-	test2 := HasOrgOrUserVisible(org, user3)
-	test3 := HasOrgOrUserVisible(org, nil)
+		&Organization{Name: org.Name, Type: UserTypeOrganization}).(*Organization)
+	test1 := HasOrgOrUserVisible(org.AsUser(), owner)
+	test2 := HasOrgOrUserVisible(org.AsUser(), user3)
+	test3 := HasOrgOrUserVisible(org.AsUser(), nil)
 	assert.True(t, test1)  // owner of org
 	assert.False(t, test2) // user not a part of org
 	assert.False(t, test3) // logged out user
diff --git a/models/repo.go b/models/repo.go
index d62b3ec2b4..3877502926 100644
--- a/models/repo.go
+++ b/models/repo.go
@@ -783,7 +783,7 @@ func (repo *Repository) CanUserDelete(user *User) (bool, error) {
 	}
 
 	if repo.Owner.IsOrganization() {
-		isOwner, err := repo.Owner.IsOwnedBy(user.ID)
+		isOwner, err := OrgFromUser(repo.Owner).IsOwnedBy(user.ID)
 		if err != nil {
 			return false, err
 		} else if isOwner {
@@ -1118,10 +1118,11 @@ func CreateRepository(ctx context.Context, doer, u *User, repo *Repository, over
 
 	// Give access to all members in teams with access to all repositories.
 	if u.IsOrganization() {
-		if err := u.loadTeams(db.GetEngine(ctx)); err != nil {
+		teams, err := OrgFromUser(u).loadTeams(db.GetEngine(ctx))
+		if err != nil {
 			return fmt.Errorf("loadTeams: %v", err)
 		}
-		for _, t := range u.Teams {
+		for _, t := range teams {
 			if t.IncludesAllRepositories {
 				if err := t.addRepository(db.GetEngine(ctx), repo); err != nil {
 					return fmt.Errorf("addRepository: %v", err)
@@ -1444,11 +1445,6 @@ func DeleteRepository(doer *User, uid, repoID int64) error {
 	if err != nil {
 		return err
 	}
-	if org.IsOrganization() {
-		if err = org.loadTeams(sess); err != nil {
-			return err
-		}
-	}
 
 	repo := &Repository{OwnerID: uid}
 	has, err := sess.ID(repoID).Get(repo)
@@ -1476,7 +1472,11 @@ func DeleteRepository(doer *User, uid, repoID int64) error {
 	}
 
 	if org.IsOrganization() {
-		for _, t := range org.Teams {
+		teams, err := OrgFromUser(org).loadTeams(sess)
+		if err != nil {
+			return err
+		}
+		for _, t := range teams {
 			if !t.hasRepository(sess, repoID) {
 				continue
 			} else if err = t.removeRepository(sess, repo, false); err != nil {
@@ -1790,8 +1790,8 @@ func GetUserMirrorRepositories(userID int64) ([]*Repository, error) {
 		Find(&repos)
 }
 
-func getRepositoryCount(e db.Engine, u *User) (int64, error) {
-	return e.Count(&Repository{OwnerID: u.ID})
+func getRepositoryCount(e db.Engine, ownerID int64) (int64, error) {
+	return e.Count(&Repository{OwnerID: ownerID})
 }
 
 func getPublicRepositoryCount(e db.Engine, u *User) (int64, error) {
@@ -1803,8 +1803,8 @@ func getPrivateRepositoryCount(e db.Engine, u *User) (int64, error) {
 }
 
 // GetRepositoryCount returns the total number of repositories of user.
-func GetRepositoryCount(ctx context.Context, u *User) (int64, error) {
-	return getRepositoryCount(db.GetEngine(ctx), u)
+func GetRepositoryCount(ctx context.Context, ownerID int64) (int64, error) {
+	return getRepositoryCount(db.GetEngine(ctx), ownerID)
 }
 
 // GetPublicRepositoryCount returns the total number of public repositories of user.
diff --git a/models/repo_test.go b/models/repo_test.go
index e6f4ea1c3f..ec1bcc0487 100644
--- a/models/repo_test.go
+++ b/models/repo_test.go
@@ -71,7 +71,7 @@ func TestMetas(t *testing.T) {
 func TestGetRepositoryCount(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	count, err1 := GetRepositoryCount(db.DefaultContext, &User{ID: int64(10)})
+	count, err1 := GetRepositoryCount(db.DefaultContext, 10)
 	privateCount, err2 := GetPrivateRepositoryCount(&User{ID: int64(10)})
 	publicCount, err3 := GetPublicRepositoryCount(&User{ID: int64(10)})
 	assert.NoError(t, err1)
diff --git a/models/repo_transfer.go b/models/repo_transfer.go
index 082c3d19dc..7b766ff4c7 100644
--- a/models/repo_transfer.go
+++ b/models/repo_transfer.go
@@ -299,16 +299,17 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) (err e
 
 	// Remove old team-repository relations.
 	if oldOwner.IsOrganization() {
-		if err := oldOwner.removeOrgRepo(sess, repo.ID); err != nil {
+		if err := OrgFromUser(oldOwner).removeOrgRepo(sess, repo.ID); err != nil {
 			return fmt.Errorf("removeOrgRepo: %v", err)
 		}
 	}
 
 	if newOwner.IsOrganization() {
-		if err := newOwner.loadTeams(sess); err != nil {
+		teams, err := OrgFromUser(newOwner).loadTeams(sess)
+		if err != nil {
 			return fmt.Errorf("LoadTeams: %v", err)
 		}
-		for _, t := range newOwner.Teams {
+		for _, t := range teams {
 			if t.IncludesAllRepositories {
 				if err := t.addRepository(sess, repo); err != nil {
 					return fmt.Errorf("addRepository: %v", err)
diff --git a/models/user.go b/models/user.go
index 1bdb435793..db2345cb37 100644
--- a/models/user.go
+++ b/models/user.go
@@ -161,9 +161,6 @@ type User struct {
 	// For organization
 	NumTeams                  int
 	NumMembers                int
-	Teams                     []*Team             `xorm:"-"`
-	Members                   UserList            `xorm:"-"`
-	MembersIsPublic           map[int64]bool      `xorm:"-"`
 	Visibility                structs.VisibleType `xorm:"NOT NULL DEFAULT 0"`
 	RepoAdminChangeTeamAccess bool                `xorm:"NOT NULL DEFAULT false"`
 
@@ -516,20 +513,6 @@ func (u *User) IsUserOrgOwner(orgID int64) bool {
 	return isOwner
 }
 
-// HasMemberWithUserID returns true if user with userID is part of the u organisation.
-func (u *User) HasMemberWithUserID(userID int64) bool {
-	return u.hasMemberWithUserID(db.GetEngine(db.DefaultContext), userID)
-}
-
-func (u *User) hasMemberWithUserID(e db.Engine, userID int64) bool {
-	isMember, err := isOrganizationMember(e, u.ID, userID)
-	if err != nil {
-		log.Error("IsOrganizationMember: %v", err)
-		return false
-	}
-	return isMember
-}
-
 // IsPublicMember returns true if user public his/her membership in given organization.
 func (u *User) IsPublicMember(orgID int64) bool {
 	isMember, err := IsPublicMembership(orgID, u.ID)
diff --git a/models/userlist_test.go b/models/userlist_test.go
index 2b8518c92f..c16a7b6eec 100644
--- a/models/userlist_test.go
+++ b/models/userlist_test.go
@@ -33,10 +33,11 @@ func TestUserListIsPublicMember(t *testing.T) {
 }
 
 func testUserListIsPublicMember(t *testing.T, orgID int64, expected map[int64]bool) {
-	org, err := GetUserByID(orgID)
+	org, err := GetOrgByID(orgID)
 	assert.NoError(t, err)
-	assert.NoError(t, org.GetMembers())
-	assert.Equal(t, expected, org.MembersIsPublic)
+	_, membersIsPublic, err := org.GetMembers()
+	assert.NoError(t, err)
+	assert.Equal(t, expected, membersIsPublic)
 }
 
 func TestUserListIsUserOrgOwner(t *testing.T) {
@@ -59,10 +60,11 @@ func TestUserListIsUserOrgOwner(t *testing.T) {
 }
 
 func testUserListIsUserOrgOwner(t *testing.T, orgID int64, expected map[int64]bool) {
-	org, err := GetUserByID(orgID)
+	org, err := GetOrgByID(orgID)
+	assert.NoError(t, err)
+	members, _, err := org.GetMembers()
 	assert.NoError(t, err)
-	assert.NoError(t, org.GetMembers())
-	assert.Equal(t, expected, org.Members.IsUserOrgOwner(orgID))
+	assert.Equal(t, expected, members.IsUserOrgOwner(orgID))
 }
 
 func TestUserListIsTwoFaEnrolled(t *testing.T) {
@@ -85,8 +87,9 @@ func TestUserListIsTwoFaEnrolled(t *testing.T) {
 }
 
 func testUserListIsTwoFaEnrolled(t *testing.T, orgID int64, expected map[int64]bool) {
-	org, err := GetUserByID(orgID)
+	org, err := GetOrgByID(orgID)
+	assert.NoError(t, err)
+	members, _, err := org.GetMembers()
 	assert.NoError(t, err)
-	assert.NoError(t, org.GetMembers())
-	assert.Equal(t, expected, org.Members.GetTwoFaStatus())
+	assert.Equal(t, expected, members.GetTwoFaStatus())
 }