From 233f0fb18df8419e841254ab2247164663566b89 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 24 Jan 2026 01:07:23 +0000 Subject: [PATCH] Migrate internal/database/org_team.go from XORM to GORM Co-authored-by: unknwon <2946214+unknwon@users.noreply.github.com> --- internal/database/org_team.go | 425 +++++++++++++++------------------- 1 file changed, 183 insertions(+), 242 deletions(-) diff --git a/internal/database/org_team.go b/internal/database/org_team.go index 2056d2f74..e3a6bfef1 100644 --- a/internal/database/org_team.go +++ b/internal/database/org_team.go @@ -6,7 +6,7 @@ import ( "strings" "github.com/cockroachdb/errors" - "xorm.io/xorm" + "gorm.io/gorm" "gogs.io/gogs/internal/errutil" ) @@ -16,7 +16,7 @@ const ownerTeamName = "Owners" // Team represents a organization team. type Team struct { ID int64 - OrgID int64 `xorm:"INDEX"` + OrgID int64 `gorm:"index"` LowerName string Name string Description string @@ -27,14 +27,12 @@ type Team struct { NumMembers int } -func (t *Team) AfterSet(colName string, _ xorm.Cell) { - switch colName { - case "num_repos": - // LEGACY [1.0]: this is backward compatibility bug fix for https://gogs.io/gogs/issues/3671 - if t.NumRepos < 0 { - t.NumRepos = 0 - } +func (t *Team) AfterFind(tx *gorm.DB) error { + // LEGACY [1.0]: this is backward compatibility bug fix for https://gogs.io/gogs/issues/3671 + if t.NumRepos < 0 { + t.NumRepos = 0 } + return nil } // IsOwnerTeam returns true if team is owner team. @@ -52,15 +50,15 @@ func (t *Team) IsMember(userID int64) bool { return IsTeamMember(t.OrgID, t.ID, userID) } -func (t *Team) getRepositories(e Engine) (err error) { +func (t *Team) getRepositories(tx *gorm.DB) (err error) { teamRepos := make([]*TeamRepo, 0, t.NumRepos) - if err = x.Where("team_id=?", t.ID).Find(&teamRepos); err != nil { + if err = tx.Where("team_id = ?", t.ID).Find(&teamRepos).Error; err != nil { return errors.Newf("get team-repos: %v", err) } t.Repos = make([]*Repository, 0, len(teamRepos)) for i := range teamRepos { - repo, err := getRepositoryByID(e, teamRepos[i].RepoID) + repo, err := getRepositoryByID(tx, teamRepos[i].RepoID) if err != nil { return errors.Newf("getRepositoryById(%d): %v", teamRepos[i].RepoID, err) } @@ -71,17 +69,17 @@ func (t *Team) getRepositories(e Engine) (err error) { // GetRepositories returns all repositories in team of organization. func (t *Team) GetRepositories() error { - return t.getRepositories(x) + return t.getRepositories(db) } -func (t *Team) getMembers(e Engine) (err error) { - t.Members, err = getTeamMembers(e, t.ID) +func (t *Team) getMembers(tx *gorm.DB) (err error) { + t.Members, err = getTeamMembers(tx, t.ID) return err } // GetMembers returns all members in team of organization. func (t *Team) GetMembers() (err error) { - return t.getMembers(x) + return t.getMembers(db) } // AddMember adds new membership of the team to the organization, @@ -95,34 +93,34 @@ func (t *Team) RemoveMember(uid int64) error { return RemoveTeamMember(t.OrgID, t.ID, uid) } -func (t *Team) hasRepository(e Engine, repoID int64) bool { - return hasTeamRepo(e, t.OrgID, t.ID, repoID) +func (t *Team) hasRepository(tx *gorm.DB, repoID int64) bool { + return hasTeamRepo(tx, t.OrgID, t.ID, repoID) } // HasRepository returns true if given repository belong to team. func (t *Team) HasRepository(repoID int64) bool { - return t.hasRepository(x, repoID) + return t.hasRepository(db, repoID) } -func (t *Team) addRepository(e Engine, repo *Repository) (err error) { - if err = addTeamRepo(e, t.OrgID, t.ID, repo.ID); err != nil { +func (t *Team) addRepository(tx *gorm.DB, repo *Repository) (err error) { + if err = addTeamRepo(tx, t.OrgID, t.ID, repo.ID); err != nil { return err } t.NumRepos++ - if _, err = e.ID(t.ID).AllCols().Update(t); err != nil { + if err = tx.Model(&Team{}).Where("id = ?", t.ID).Updates(t).Error; err != nil { return errors.Newf("update team: %v", err) } - if err = repo.recalculateTeamAccesses(e, 0); err != nil { + if err = repo.recalculateTeamAccesses(tx, 0); err != nil { return errors.Newf("recalculateAccesses: %v", err) } - if err = t.getMembers(e); err != nil { + if err = t.getMembers(tx); err != nil { return errors.Newf("getMembers: %v", err) } for _, u := range t.Members { - if err = watchRepo(e, u.ID, repo.ID, true); err != nil { + if err = watchRepo(tx, u.ID, repo.ID, true); err != nil { return errors.Newf("watchRepo: %v", err) } } @@ -137,42 +135,34 @@ func (t *Team) AddRepository(repo *Repository) (err error) { return nil } - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { - return err - } - - if err = t.addRepository(sess, repo); err != nil { - return err - } - - return sess.Commit() + return db.Transaction(func(tx *gorm.DB) error { + return t.addRepository(tx, repo) + }) } -func (t *Team) removeRepository(e Engine, repo *Repository, recalculate bool) (err error) { - if err = removeTeamRepo(e, t.ID, repo.ID); err != nil { +func (t *Team) removeRepository(tx *gorm.DB, repo *Repository, recalculate bool) (err error) { + if err = removeTeamRepo(tx, t.ID, repo.ID); err != nil { return err } t.NumRepos-- - if _, err = e.ID(t.ID).AllCols().Update(t); err != nil { + if err = tx.Model(&Team{}).Where("id = ?", t.ID).Updates(t).Error; err != nil { return err } // Don't need to recalculate when delete a repository from organization. if recalculate { - if err = repo.recalculateTeamAccesses(e, t.ID); err != nil { + if err = repo.recalculateTeamAccesses(tx, t.ID); err != nil { return err } } - if err = t.getMembers(e); err != nil { + if err = t.getMembers(tx); err != nil { return errors.Newf("get team members: %v", err) } // TODO: Delete me when this method is migrated to use GORM. - userAccessMode := func(e Engine, userID int64, repo *Repository) (AccessMode, error) { + userAccessMode := func(tx *gorm.DB, userID int64, repo *Repository) (AccessMode, error) { mode := AccessModeNone // Everyone has read access to public repository if !repo.IsPrivate { @@ -191,26 +181,29 @@ func (t *Team) removeRepository(e Engine, repo *Repository, recalculate bool) (e UserID: userID, RepoID: repo.ID, } - if has, err := e.Get(access); !has || err != nil { + err := tx.Where("user_id = ? AND repo_id = ?", userID, repo.ID).First(access).Error + if errors.Is(err, gorm.ErrRecordNotFound) { + return mode, nil + } else if err != nil { return mode, err } return access.Mode, nil } - hasAccess := func(e Engine, userID int64, repo *Repository, testMode AccessMode) (bool, error) { - mode, err := userAccessMode(e, userID, repo) + hasAccess := func(tx *gorm.DB, userID int64, repo *Repository, testMode AccessMode) (bool, error) { + mode, err := userAccessMode(tx, userID, repo) return mode >= testMode, err } for _, member := range t.Members { - has, err := hasAccess(e, member.ID, repo, AccessModeRead) + has, err := hasAccess(tx, member.ID, repo, AccessModeRead) if err != nil { return err } else if has { continue } - if err = watchRepo(e, member.ID, repo.ID, false); err != nil { + if err = watchRepo(tx, member.ID, repo.ID, false); err != nil { return err } } @@ -229,17 +222,9 @@ func (t *Team) RemoveRepository(repoID int64) error { return err } - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { - return err - } - - if err = t.removeRepository(sess, repo, true); err != nil { - return err - } - - return sess.Commit() + return db.Transaction(func(tx *gorm.DB) error { + return t.removeRepository(tx, repo, true) + }) } var reservedTeamNames = map[string]struct{}{ @@ -264,37 +249,30 @@ func NewTeam(t *Team) error { return err } - has, err := x.Id(t.OrgID).Get(new(User)) - if err != nil { - return err - } else if !has { + err := db.Where("id = ?", t.OrgID).First(new(User)).Error + if errors.Is(err, gorm.ErrRecordNotFound) { return ErrOrgNotExist + } else if err != nil { + return err } t.LowerName = strings.ToLower(t.Name) existingTeam := Team{} - has, err = x.Where("org_id=?", t.OrgID).And("lower_name=?", t.LowerName).Get(&existingTeam) - if err != nil { - return err - } else if has { + err = db.Where("org_id = ? AND lower_name = ?", t.OrgID, t.LowerName).First(&existingTeam).Error + if err == nil { return ErrTeamAlreadyExist{existingTeam.ID, t.OrgID, t.LowerName} - } - - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { + } else if !errors.Is(err, gorm.ErrRecordNotFound) { return err } - if _, err = sess.Insert(t); err != nil { - return err - } + return db.Transaction(func(tx *gorm.DB) error { + if err := tx.Create(t).Error; err != nil { + return err + } - // Update organization number of teams. - if _, err = sess.Exec("UPDATE `user` SET num_teams=num_teams+1 WHERE id = ?", t.OrgID); err != nil { - return err - } - return sess.Commit() + // Update organization number of teams. + return tx.Exec("UPDATE `user` SET num_teams=num_teams+1 WHERE id = ?", t.OrgID).Error + }) } var _ errutil.NotFound = (*ErrTeamNotExist)(nil) @@ -316,49 +294,46 @@ func (ErrTeamNotExist) NotFound() bool { return true } -func getTeamOfOrgByName(e Engine, orgID int64, name string) (*Team, error) { - t := &Team{ - OrgID: orgID, - LowerName: strings.ToLower(name), - } - has, err := e.Get(t) - if err != nil { - return nil, err - } else if !has { +func getTeamOfOrgByName(tx *gorm.DB, orgID int64, name string) (*Team, error) { + t := new(Team) + err := tx.Where("org_id = ? AND lower_name = ?", orgID, strings.ToLower(name)).First(t).Error + if errors.Is(err, gorm.ErrRecordNotFound) { return nil, ErrTeamNotExist{args: map[string]any{"orgID": orgID, "name": name}} + } else if err != nil { + return nil, err } return t, nil } // GetTeamOfOrgByName returns team by given team name and organization. func GetTeamOfOrgByName(orgID int64, name string) (*Team, error) { - return getTeamOfOrgByName(x, orgID, name) + return getTeamOfOrgByName(db, orgID, name) } -func getTeamByID(e Engine, teamID int64) (*Team, error) { +func getTeamByID(tx *gorm.DB, teamID int64) (*Team, error) { t := new(Team) - has, err := e.ID(teamID).Get(t) - if err != nil { - return nil, err - } else if !has { + err := tx.Where("id = ?", teamID).First(t).Error + if errors.Is(err, gorm.ErrRecordNotFound) { return nil, ErrTeamNotExist{args: map[string]any{"teamID": teamID}} + } else if err != nil { + return nil, err } return t, nil } // GetTeamByID returns team by given ID. func GetTeamByID(teamID int64) (*Team, error) { - return getTeamByID(x, teamID) + return getTeamByID(db, teamID) } -func getTeamsByOrgID(e Engine, orgID int64) ([]*Team, error) { +func getTeamsByOrgID(tx *gorm.DB, orgID int64) ([]*Team, error) { teams := make([]*Team, 0, 3) - return teams, e.Where("org_id = ?", orgID).Find(&teams) + return teams, tx.Where("org_id = ?", orgID).Find(&teams).Error } // GetTeamsByOrgID returns all teams belong to given organization. func GetTeamsByOrgID(orgID int64) ([]*Team, error) { - return getTeamsByOrgID(x, orgID) + return getTeamsByOrgID(db, orgID) } // UpdateTeam updates information of team. @@ -371,39 +346,35 @@ func UpdateTeam(t *Team, authChanged bool) (err error) { t.Description = t.Description[:255] } - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { - return err - } - t.LowerName = strings.ToLower(t.Name) existingTeam := new(Team) - has, err := x.Where("org_id=?", t.OrgID).And("lower_name=?", t.LowerName).And("id!=?", t.ID).Get(existingTeam) - if err != nil { - return err - } else if has { + err = db.Where("org_id = ? AND lower_name = ? AND id != ?", t.OrgID, t.LowerName, t.ID).First(existingTeam).Error + if err == nil { return ErrTeamAlreadyExist{existingTeam.ID, t.OrgID, t.LowerName} + } else if !errors.Is(err, gorm.ErrRecordNotFound) { + return err } - if _, err = sess.ID(t.ID).AllCols().Update(t); err != nil { - return errors.Newf("update: %v", err) - } - - // Update access for team members if needed. - if authChanged { - if err = t.getRepositories(sess); err != nil { - return errors.Newf("getRepositories:%v", err) + return db.Transaction(func(tx *gorm.DB) error { + if err := tx.Model(&Team{}).Where("id = ?", t.ID).Updates(t).Error; err != nil { + return errors.Newf("update: %v", err) } - for _, repo := range t.Repos { - if err = repo.recalculateTeamAccesses(sess, 0); err != nil { - return errors.Newf("recalculateTeamAccesses: %v", err) + // Update access for team members if needed. + if authChanged { + if err := t.getRepositories(tx); err != nil { + return errors.Newf("getRepositories:%v", err) + } + + for _, repo := range t.Repos { + if err := repo.recalculateTeamAccesses(tx, 0); err != nil { + return errors.Newf("recalculateTeamAccesses: %v", err) + } } } - } - return sess.Commit() + return nil + }) } // DeleteTeam deletes given team. @@ -419,34 +390,26 @@ func DeleteTeam(t *Team) error { return err } - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { - return err - } + return db.Transaction(func(tx *gorm.DB) error { + // Delete all accesses. + for _, repo := range t.Repos { + if err := repo.recalculateTeamAccesses(tx, t.ID); err != nil { + return err + } + } - // Delete all accesses. - for _, repo := range t.Repos { - if err = repo.recalculateTeamAccesses(sess, t.ID); err != nil { + // Delete team-user. + if err := tx.Where("org_id = ? AND team_id = ?", org.ID, t.ID).Delete(new(TeamUser)).Error; err != nil { return err } - } - // Delete team-user. - if _, err = sess.Where("org_id=?", org.ID).Where("team_id=?", t.ID).Delete(new(TeamUser)); err != nil { - return err - } - - // Delete team. - if _, err = sess.ID(t.ID).Delete(new(Team)); err != nil { - return err - } - // Update organization number of teams. - if _, err = sess.Exec("UPDATE `user` SET num_teams=num_teams-1 WHERE id=?", t.OrgID); err != nil { - return err - } - - return sess.Commit() + // Delete team. + if err := tx.Where("id = ?", t.ID).Delete(new(Team)).Error; err != nil { + return err + } + // Update organization number of teams. + return tx.Exec("UPDATE `user` SET num_teams=num_teams-1 WHERE id = ?", t.OrgID).Error + }) } // ___________ ____ ___ @@ -459,31 +422,30 @@ func DeleteTeam(t *Team) error { // TeamUser represents an team-user relation. type TeamUser struct { ID int64 - OrgID int64 `xorm:"INDEX"` - TeamID int64 `xorm:"UNIQUE(s)"` - UID int64 `xorm:"UNIQUE(s)"` + OrgID int64 `gorm:"index"` + TeamID int64 `gorm:"uniqueIndex:team_user_team_id_uid"` + UID int64 `gorm:"uniqueIndex:team_user_team_id_uid"` } -func isTeamMember(e Engine, orgID, teamID, uid int64) bool { - has, _ := e.Where("org_id=?", orgID).And("team_id=?", teamID).And("uid=?", uid).Get(new(TeamUser)) - return has +func isTeamMember(tx *gorm.DB, orgID, teamID, uid int64) bool { + err := tx.Where("org_id = ? AND team_id = ? AND uid = ?", orgID, teamID, uid).First(new(TeamUser)).Error + return err == nil } // IsTeamMember returns true if given user is a member of team. func IsTeamMember(orgID, teamID, uid int64) bool { - return isTeamMember(x, orgID, teamID, uid) + return isTeamMember(db, orgID, teamID, uid) } -func getTeamMembers(e Engine, teamID int64) (_ []*User, err error) { +func getTeamMembers(tx *gorm.DB, teamID int64) (_ []*User, err error) { teamUsers := make([]*TeamUser, 0, 10) - if err = e.Sql("SELECT `id`, `org_id`, `team_id`, `uid` FROM `team_user` WHERE team_id = ?", teamID). - Find(&teamUsers); err != nil { + if err = tx.Select("id, org_id, team_id, uid").Where("team_id = ?", teamID).Find(&teamUsers).Error; err != nil { return nil, errors.Newf("get team-users: %v", err) } members := make([]*User, 0, len(teamUsers)) for i := range teamUsers { member := new(User) - if _, err = e.ID(teamUsers[i].UID).Get(member); err != nil { + if err = tx.Where("id = ?", teamUsers[i].UID).First(member).Error; err != nil { return nil, errors.Newf("get user '%d': %v", teamUsers[i].UID, err) } members = append(members, member) @@ -493,12 +455,12 @@ func getTeamMembers(e Engine, teamID int64) (_ []*User, err error) { // GetTeamMembers returns all members in given team of organization. func GetTeamMembers(teamID int64) ([]*User, error) { - return getTeamMembers(x, teamID) + return getTeamMembers(db, teamID) } -func getUserTeams(e Engine, orgID, userID int64) ([]*Team, error) { +func getUserTeams(tx *gorm.DB, orgID, userID int64) ([]*Team, error) { teamUsers := make([]*TeamUser, 0, 5) - if err := e.Where("uid = ?", userID).And("org_id = ?", orgID).Find(&teamUsers); err != nil { + if err := tx.Where("uid = ? AND org_id = ?", userID, orgID).Find(&teamUsers).Error; err != nil { return nil, err } @@ -509,12 +471,12 @@ func getUserTeams(e Engine, orgID, userID int64) ([]*Team, error) { teamIDs[len(teamUsers)] = -1 teams := make([]*Team, 0, len(teamIDs)) - return teams, e.Where("org_id = ?", orgID).In("id", teamIDs).Find(&teams) + return teams, tx.Where("org_id = ? AND id IN ?", orgID, teamIDs).Find(&teams).Error } // GetUserTeams returns all teams that user belongs to in given organization. func GetUserTeams(orgID, userID int64) ([]*Team, error) { - return getUserTeams(x, orgID, userID) + return getUserTeams(db, orgID, userID) } // AddTeamMember adds new membership of given team to given organization, @@ -539,53 +501,46 @@ func AddTeamMember(orgID, teamID, userID int64) error { return err } - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { - return err - } - - tu := &TeamUser{ - UID: userID, - OrgID: orgID, - TeamID: teamID, - } - if _, err = sess.Insert(tu); err != nil { - return err - } else if _, err = sess.ID(t.ID).Update(t); err != nil { - return err - } - - // Give access to team repositories. - for _, repo := range t.Repos { - if err = repo.recalculateTeamAccesses(sess, 0); err != nil { + return db.Transaction(func(tx *gorm.DB) error { + tu := &TeamUser{ + UID: userID, + OrgID: orgID, + TeamID: teamID, + } + if err := tx.Create(tu).Error; err != nil { + return err + } + if err := tx.Model(&Team{}).Where("id = ?", t.ID).Updates(t).Error; err != nil { return err } - } - // We make sure it exists before. - ou := new(OrgUser) - if _, err = sess.Where("uid = ?", userID).And("org_id = ?", orgID).Get(ou); err != nil { - return err - } - ou.NumTeams++ - if t.IsOwnerTeam() { - ou.IsOwner = true - } - if _, err = sess.ID(ou.ID).AllCols().Update(ou); err != nil { - return err - } + // Give access to team repositories. + for _, repo := range t.Repos { + if err := repo.recalculateTeamAccesses(tx, 0); err != nil { + return err + } + } - return sess.Commit() + // We make sure it exists before. + ou := new(OrgUser) + if err := tx.Where("uid = ? AND org_id = ?", userID, orgID).First(ou).Error; err != nil { + return err + } + ou.NumTeams++ + if t.IsOwnerTeam() { + ou.IsOwner = true + } + return tx.Model(&OrgUser{}).Where("id = ?", ou.ID).Updates(ou).Error + }) } -func removeTeamMember(e Engine, orgID, teamID, uid int64) error { - if !isTeamMember(e, orgID, teamID, uid) { +func removeTeamMember(tx *gorm.DB, orgID, teamID, uid int64) error { + if !isTeamMember(tx, orgID, teamID, uid) { return nil } // Get team and its repositories. - t, err := getTeamByID(e, teamID) + t, err := getTeamByID(tx, teamID) if err != nil { return err } @@ -597,12 +552,12 @@ func removeTeamMember(e Engine, orgID, teamID, uid int64) error { t.NumMembers-- - if err = t.getRepositories(e); err != nil { + if err = t.getRepositories(tx); err != nil { return err } // Get organization. - org, err := getUserByID(e, orgID) + org, err := getUserByID(tx, orgID) if err != nil { return err } @@ -612,46 +567,37 @@ func removeTeamMember(e Engine, orgID, teamID, uid int64) error { OrgID: orgID, TeamID: teamID, } - if _, err := e.Delete(tu); err != nil { + if err := tx.Where("uid = ? AND org_id = ? AND team_id = ?", uid, orgID, teamID).Delete(tu).Error; err != nil { return err - } else if _, err = e.ID(t.ID).AllCols().Update(t); err != nil { + } + if err = tx.Model(&Team{}).Where("id = ?", t.ID).Updates(t).Error; err != nil { return err } // Delete access to team repositories. for _, repo := range t.Repos { - if err = repo.recalculateTeamAccesses(e, 0); err != nil { + if err = repo.recalculateTeamAccesses(tx, 0); err != nil { return err } } // This must exist. ou := new(OrgUser) - _, err = e.Where("uid = ?", uid).And("org_id = ?", org.ID).Get(ou) - if err != nil { + if err = tx.Where("uid = ? AND org_id = ?", uid, org.ID).First(ou).Error; err != nil { return err } ou.NumTeams-- if t.IsOwnerTeam() { ou.IsOwner = false } - if _, err = e.ID(ou.ID).AllCols().Update(ou); err != nil { - return err - } - return nil + return tx.Model(&OrgUser{}).Where("id = ?", ou.ID).Updates(ou).Error } // RemoveTeamMember removes member from given team of given organization. func RemoveTeamMember(orgID, teamID, uid int64) error { - sess := x.NewSession() - defer sess.Close() - if err := sess.Begin(); err != nil { - return err - } - if err := removeTeamMember(sess, orgID, teamID, uid); err != nil { - return err - } - return sess.Commit() + return db.Transaction(func(tx *gorm.DB) error { + return removeTeamMember(tx, orgID, teamID, uid) + }) } // ___________ __________ @@ -664,54 +610,49 @@ func RemoveTeamMember(orgID, teamID, uid int64) error { // TeamRepo represents an team-repository relation. type TeamRepo struct { ID int64 - OrgID int64 `xorm:"INDEX"` - TeamID int64 `xorm:"UNIQUE(s)"` - RepoID int64 `xorm:"UNIQUE(s)"` + OrgID int64 `gorm:"index"` + TeamID int64 `gorm:"uniqueIndex:team_repo_team_id_repo_id"` + RepoID int64 `gorm:"uniqueIndex:team_repo_team_id_repo_id"` } -func hasTeamRepo(e Engine, orgID, teamID, repoID int64) bool { - has, _ := e.Where("org_id = ?", orgID).And("team_id = ?", teamID).And("repo_id = ?", repoID).Get(new(TeamRepo)) - return has +func hasTeamRepo(tx *gorm.DB, orgID, teamID, repoID int64) bool { + err := tx.Where("org_id = ? AND team_id = ? AND repo_id = ?", orgID, teamID, repoID).First(new(TeamRepo)).Error + return err == nil } // HasTeamRepo returns true if given team has access to the repository of the organization. func HasTeamRepo(orgID, teamID, repoID int64) bool { - return hasTeamRepo(x, orgID, teamID, repoID) + return hasTeamRepo(db, orgID, teamID, repoID) } -func addTeamRepo(e Engine, orgID, teamID, repoID int64) error { - _, err := e.InsertOne(&TeamRepo{ +func addTeamRepo(tx *gorm.DB, orgID, teamID, repoID int64) error { + return tx.Create(&TeamRepo{ OrgID: orgID, TeamID: teamID, RepoID: repoID, - }) - return err + }).Error } // AddTeamRepo adds new repository relation to team. func AddTeamRepo(orgID, teamID, repoID int64) error { - return addTeamRepo(x, orgID, teamID, repoID) + return addTeamRepo(db, orgID, teamID, repoID) } -func removeTeamRepo(e Engine, teamID, repoID int64) error { - _, err := e.Delete(&TeamRepo{ - TeamID: teamID, - RepoID: repoID, - }) - return err +func removeTeamRepo(tx *gorm.DB, teamID, repoID int64) error { + return tx.Where("team_id = ? AND repo_id = ?", teamID, repoID).Delete(new(TeamRepo)).Error } // RemoveTeamRepo deletes repository relation to team. func RemoveTeamRepo(teamID, repoID int64) error { - return removeTeamRepo(x, teamID, repoID) + return removeTeamRepo(db, teamID, repoID) } // GetTeamsHaveAccessToRepo returns all teams in an organization that have given access level to the repository. func GetTeamsHaveAccessToRepo(orgID, repoID int64, mode AccessMode) ([]*Team, error) { teams := make([]*Team, 0, 5) - return teams, x.Where("team.authorize >= ?", mode). - Join("INNER", "team_repo", "team_repo.team_id = team.id"). - And("team_repo.org_id = ?", orgID). - And("team_repo.repo_id = ?", repoID). - Find(&teams) + return teams, db.Table("team"). + Where("team.authorize >= ?", mode). + Joins("INNER JOIN team_repo ON team_repo.team_id = team.id"). + Where("team_repo.org_id = ? AND team_repo.repo_id = ?", orgID, repoID). + Find(&teams).Error }