}
return true, nil
}
+
+// GetAccessibleRepositories finds all repositories where a user has access to,
+// besides his own.
+func (u *User) GetAccessibleRepositories() (map[*Repository]AccessType, error) {
+ accesses := make([]*Access, 0, 10)
+ if err := x.Find(&accesses, &Access{UserName: u.LowerName}); err != nil {
+ return nil, err
+ }
+
+ repos := make(map[*Repository]AccessType, len(accesses))
+ for _, access := range accesses {
+ repo, err := GetRepositoryByRef(access.RepoName)
+ if err != nil {
+ return nil, err
+ }
+ repos[repo] = access.Mode
+ }
+
+ return repos, nil
+}
}
// NewIssueUserPairs adds new issue-user pairs for new issue of repository.
-func NewIssueUserPairs(rid, iid, oid, pid, aid int64, repoName string) (err error) {
- iu := &IssueUser{IssueId: iid, RepoId: rid}
+func NewIssueUserPairs(repo *Repository, iid, oid, pid, aid int64) (err error) {
+ iu := &IssueUser{IssueId: iid, RepoId: repo.Id}
- us, err := GetCollaborators(repoName)
+ us, err := repo.GetCollaborators()
if err != nil {
return err
}
import (
"errors"
+ "strconv"
+ "strings"
+ "time"
"github.com/go-xorm/xorm"
)
// This is a sequence of migrations. Add new migrations to the bottom of the list.
// If you want to "retire" a migration, replace it with "expiredMigration"
-var migrations = []migration{}
+var migrations = []migration{
+ accessToCollaboration,
+}
// Migrate database to current version
func Migrate(x *xorm.Engine) error {
if err != nil {
return err
} else if !has {
+ needsMigration, err := x.IsTableExist("user")
+ if err != nil {
+ return err
+ }
+ if needsMigration {
+ isEmpty, err := x.IsTableEmpty("user")
+ if err != nil {
+ return err
+ }
+ needsMigration = !isEmpty
+ }
+ if !needsMigration {
+ currentVersion.Version = int64(len(migrations))
+ }
+
if _, err = x.InsertOne(currentVersion); err != nil {
return err
}
func expiredMigration(x *xorm.Engine) error {
return errors.New("You are migrating from a too old gogs version")
}
+
+func mustParseInt64(in []byte) int64 {
+ i, err := strconv.ParseInt(string(in), 10, 64)
+ if err != nil {
+ i = 0
+ }
+ return i
+}
+
+func accessToCollaboration(x *xorm.Engine) error {
+ type Collaboration struct {
+ ID int64 `xorm:"pk autoincr"`
+ RepoID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
+ UserID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
+ Created time.Time `xorm:"CREATED"`
+ }
+
+ x.Sync(new(Collaboration))
+
+ sql := `SELECT u.id AS uid, a.repo_name AS repo, a.mode AS mode FROM access a JOIN user u ON a.user_name=u.lower_name`
+ results, err := x.Query(sql)
+ if err != nil {
+ return err
+ }
+
+ for _, result := range results {
+ userID := mustParseInt64(result["uid"])
+ repoRefName := string(result["repo"])
+ mode := mustParseInt64(result["mode"])
+
+ //Collaborators must have write access
+ if mode < 2 {
+ continue
+ }
+
+ parts := strings.SplitN(repoRefName, "/", 2)
+ ownerName := parts[0]
+ repoName := parts[1]
+
+ sql = `SELECT u.id as uid, ou.uid as memberid FROM user u LEFT JOIN org_user ou ON ou.org_id=u.id WHERE u.lower_name=?`
+ results, err := x.Query(sql, ownerName)
+ if err != nil {
+ return err
+ }
+ if len(results) < 1 {
+ continue
+ }
+ ownerID := mustParseInt64(results[0]["uid"])
+
+ for _, member := range results {
+ memberID := mustParseInt64(member["memberid"])
+ // We can skip all cases that a user is member of the owning organization
+ if memberID == userID {
+ continue
+ }
+ }
+
+ sql = `SELECT id FROM repository WHERE owner_id=? AND lower_name=?`
+ results, err = x.Query(sql, ownerID, repoName)
+ if err != nil {
+ return err
+ }
+ if len(results) < 1 {
+ continue
+ }
+
+ repoID := results[0]["id"]
+
+ sql = `INSERT INTO collaboration (user_id, repo_id) VALUES (?,?)`
+ _, err = x.Exec(sql, userID, repoID)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
"strings"
_ "github.com/go-sql-driver/mysql"
+ "github.com/go-xorm/core"
"github.com/go-xorm/xorm"
_ "github.com/lib/pq"
new(Issue), new(Comment), new(Attachment), new(IssueUser), new(Label), new(Milestone),
new(Mirror), new(Release), new(LoginSource), new(Webhook),
new(UpdateTask), new(HookTask), new(Team), new(OrgUser), new(TeamUser),
- new(Notice), new(EmailAddress))
+ new(Notice), new(EmailAddress), new(Collaboration))
}
func LoadModelsConfig() {
return fmt.Errorf("models.init(fail to connect to database): %v", err)
}
+ x.SetMapper(core.GonicMapper{})
return x.Sync(tables...)
}
return fmt.Errorf("models.init(fail to connect to database): %v", err)
}
+ x.SetMapper(core.GonicMapper{})
+
// WARNING: for serv command, MUST remove the output to os.stdout,
// so use log file to instead print to stdout.
logPath := path.Join(setting.LogRootPath, "xorm.log")
if err = x.StoreEngine("InnoDB").Sync2(tables...); err != nil {
return fmt.Errorf("sync database struct error: %v\n", err)
}
+
return nil
}
return x.Count(&Repository{OwnerId: user.Id})
}
-// GetCollaboratorNames returns a list of user name of repository's collaborators.
-func GetCollaboratorNames(repoName string) ([]string, error) {
- accesses := make([]*Access, 0, 10)
- if err := x.Find(&accesses, &Access{RepoName: strings.ToLower(repoName)}); err != nil {
+// GetCollaborators returns the collaborators for a repository
+func (r *Repository) GetCollaborators() ([]*User, error) {
+ collaborations := make([]*Collaboration, 0)
+ if err := x.Find(&collaborations, &Collaboration{RepoID: r.Id}); err != nil {
return nil, err
}
- names := make([]string, len(accesses))
- for i := range accesses {
- names[i] = accesses[i].UserName
+ users := make([]*User, len(collaborations))
+ for i, c := range collaborations {
+ user, err := GetUserById(c.UserID)
+ if err != nil {
+ return nil, err
+ }
+ users[i] = user
}
- return names, nil
+ return users, nil
}
-// CollaborativeRepository represents a repository with collaborative information.
-type CollaborativeRepository struct {
- *Repository
- CanPush bool
-}
+// Add collaborator and accompanying access
+func (r *Repository) AddCollaborator(u *User) error {
+ collaboration := &Collaboration{RepoID: r.Id, UserID: u.Id}
-// GetCollaborativeRepos returns a list of repositories that user is collaborator.
-func GetCollaborativeRepos(uname string) ([]*CollaborativeRepository, error) {
- uname = strings.ToLower(uname)
- accesses := make([]*Access, 0, 10)
- if err := x.Find(&accesses, &Access{UserName: uname}); err != nil {
- return nil, err
+ has, err := x.Get(collaboration)
+ if err != nil {
+ return err
+ }
+ if has {
+ return nil
}
- repos := make([]*CollaborativeRepository, 0, 10)
- for _, access := range accesses {
- infos := strings.Split(access.RepoName, "/")
- if infos[0] == uname {
- continue
- }
-
- u, err := GetUserByName(infos[0])
- if err != nil {
- return nil, err
- }
+ if _, err = x.InsertOne(collaboration); err != nil {
+ return err
+ }
- repo, err := GetRepositoryByName(u.Id, infos[1])
- if err != nil {
- return nil, err
- }
- repo.Owner = u
- repos = append(repos, &CollaborativeRepository{repo, access.Mode == WRITABLE})
+ if err = r.GetOwner(); err != nil {
+ return err
}
- return repos, nil
+
+ return AddAccess(&Access{UserName: u.LowerName, RepoName: path.Join(r.Owner.LowerName, r.LowerName), Mode: WRITABLE})
}
-// GetCollaborators returns a list of users of repository's collaborators.
-func GetCollaborators(repoName string) (us []*User, err error) {
- accesses := make([]*Access, 0, 10)
- if err = x.Find(&accesses, &Access{RepoName: strings.ToLower(repoName)}); err != nil {
- return nil, err
+// Delete collaborator and accompanying access
+func (r *Repository) DeleteCollaborator(u *User) error {
+ collaboration := &Collaboration{RepoID: r.Id, UserID: u.Id}
+
+ if has, err := x.Delete(collaboration); err != nil || has == 0 {
+ return err
}
- us = make([]*User, len(accesses))
- for i := range accesses {
- us[i], err = GetUserByName(accesses[i].UserName)
+ if err := r.GetOwner(); err != nil {
+ return err
+ }
+
+ needDelete := true
+ if r.Owner.IsOrganization() {
+ auth, err := GetHighestAuthorize(r.Owner.Id, u.Id, r.Id, 0)
if err != nil {
- return nil, err
+ return err
}
+ if auth > 0 {
+ needDelete = false
+ }
+ }
+ if needDelete {
+ return DeleteAccess(&Access{UserName: u.LowerName, RepoName: path.Join(r.Owner.LowerName, r.LowerName), Mode: WRITABLE})
}
- return us, nil
+
+ return nil
}
type SearchOption struct {
return repo, nil
}
+
+// A Collaboration is a relation between an individual and a repository
+type Collaboration struct {
+ ID int64 `xorm:"pk autoincr"`
+ RepoID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
+ UserID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
+ Created time.Time `xorm:"CREATED"`
+}
}
numOwnRepos := len(ownRepos)
- collaRepos, err := models.GetCollaborativeRepos(ctx.User.Name)
+ accessibleRepos, err := ctx.User.GetAccessibleRepositories()
if err != nil {
- ctx.JSON(500, &base.ApiJsonErr{"GetCollaborativeRepos: " + err.Error(), base.DOC_URL})
+ ctx.JSON(500, &base.ApiJsonErr{"GetAccessibleRepositories: " + err.Error(), base.DOC_URL})
return
}
- repos := make([]*api.Repository, numOwnRepos+len(collaRepos))
+ repos := make([]*api.Repository, numOwnRepos+len(accessibleRepos))
for i := range ownRepos {
repos[i] = ToApiRepository(ctx.User, ownRepos[i], api.Permission{true, true, true})
}
- for i := range collaRepos {
- if err = collaRepos[i].GetOwner(); err != nil {
+ i := numOwnRepos
+
+ for repo, access := range accessibleRepos {
+ if err = repo.GetOwner(); err != nil {
ctx.JSON(500, &base.ApiJsonErr{"GetOwner: " + err.Error(), base.DOC_URL})
return
}
- j := i + numOwnRepos
- repos[j] = ToApiRepository(collaRepos[i].Owner, collaRepos[i].Repository, api.Permission{false, collaRepos[i].CanPush, true})
+
+ repos[i] = ToApiRepository(repo.Owner, repo, api.Permission{false, access >= models.WRITABLE, true})
// FIXME: cache result to reduce DB query?
- if collaRepos[i].Owner.IsOrganization() && collaRepos[i].Owner.IsOwnedBy(ctx.User.Id) {
- repos[j].Permissions.Admin = true
+ if repo.Owner.IsOrganization() && repo.Owner.IsOwnedBy(ctx.User.Id) {
+ repos[i].Permissions.Admin = true
}
+ i++
}
ctx.JSON(200, &repos)
return
}
- us, err := models.GetCollaborators(strings.TrimPrefix(ctx.Repo.RepoLink, "/"))
+ us, err := ctx.Repo.Repository.GetCollaborators()
if err != nil {
ctx.Handle(500, "issue.CreateIssue(GetCollaborators)", err)
return
return
}
- _, err = models.GetCollaborators(strings.TrimPrefix(ctx.Repo.RepoLink, "/"))
+ _, err = ctx.Repo.Repository.GetCollaborators()
if err != nil {
send(500, nil, err)
return
if err := models.NewIssue(issue); err != nil {
send(500, nil, err)
return
- } else if err := models.NewIssueUserPairs(issue.RepoId, issue.Id, ctx.Repo.Owner.Id,
- ctx.User.Id, form.AssigneeId, ctx.Repo.Repository.Name); err != nil {
+ } else if err := models.NewIssueUserPairs(ctx.Repo.Repository, issue.Id, ctx.Repo.Owner.Id,
+ ctx.User.Id, form.AssigneeId); err != nil {
send(500, nil, err)
return
}
}
// Get all collaborators.
- ctx.Data["Collaborators"], err = models.GetCollaborators(strings.TrimPrefix(ctx.Repo.RepoLink, "/"))
+ ctx.Data["Collaborators"], err = ctx.Repo.Repository.GetCollaborators()
if err != nil {
ctx.Handle(500, "issue.CreateIssue(GetCollaborators)", err)
return
// testing route handler for new issue ui page
// todo : move to Issue() function
-func Issues2(ctx *middleware.Context){
- ctx.HTML(200,"repo/issue2/list")
+func Issues2(ctx *middleware.Context) {
+ ctx.HTML(200, "repo/issue2/list")
}
-func PullRequest2(ctx *middleware.Context){
- ctx.HTML(200,"repo/pr2/list")
+func PullRequest2(ctx *middleware.Context) {
+ ctx.HTML(200, "repo/pr2/list")
}
-func Labels2(ctx *middleware.Context){
- ctx.HTML(200,"repo/issue2/labels")
+func Labels2(ctx *middleware.Context) {
+ ctx.HTML(200, "repo/issue2/labels")
}
-func Milestones2(ctx *middleware.Context){
- ctx.HTML(200,"repo/milestone2/list")
+func Milestones2(ctx *middleware.Context) {
+ ctx.HTML(200, "repo/milestone2/list")
}
"fmt"
"strings"
"time"
- "path"
"github.com/Unknwon/com"
ctx.Data["Title"] = ctx.Tr("repo.settings")
ctx.Data["PageIsSettingsCollaboration"] = true
- repoLink := path.Join(ctx.Repo.Owner.LowerName, ctx.Repo.Repository.LowerName)
-
if ctx.Req.Method == "POST" {
name := strings.ToLower(ctx.Query("collaborator"))
if len(name) == 0 || ctx.Repo.Owner.LowerName == name {
ctx.Redirect(setting.AppSubUrl + ctx.Req.URL.Path)
return
}
- has, err := models.HasAccess(name, repoLink, models.WRITABLE)
- if err != nil {
- ctx.Handle(500, "HasAccess", err)
- return
- } else if has {
- ctx.Redirect(setting.AppSubUrl + ctx.Req.URL.Path)
- return
- }
u, err := models.GetUserByName(name)
if err != nil {
return
}
- if err = models.AddAccess(&models.Access{UserName: name, RepoName: repoLink,
- Mode: models.WRITABLE}); err != nil {
- ctx.Handle(500, "AddAccess", err)
+ if err = ctx.Repo.Repository.AddCollaborator(u); err != nil {
+ ctx.Handle(500, "AddCollaborator", err)
return
}
// Delete collaborator.
remove := strings.ToLower(ctx.Query("remove"))
if len(remove) > 0 && remove != ctx.Repo.Owner.LowerName {
- needDelete := true
- if ctx.User.IsOrganization() {
- // Check if user belongs to a team that has access to this repository.
- auth, err := models.GetHighestAuthorize(ctx.Repo.Owner.Id, ctx.User.Id, ctx.Repo.Repository.Id, 0)
- if err != nil {
- ctx.Handle(500, "GetHighestAuthorize", err)
- return
- }
- if auth > 0 {
- needDelete = false
- }
+ u, err := models.GetUserByName(remove)
+ if err != nil {
+ ctx.Handle(500, "GetUserByName", err)
+ return
}
-
- if needDelete {
- if err := models.DeleteAccess(&models.Access{UserName: remove, RepoName: repoLink}); err != nil {
- ctx.Handle(500, "DeleteAccess", err)
- return
- }
+ if err := ctx.Repo.Repository.DeleteCollaborator(u); err != nil {
+ ctx.Handle(500, "DeleteCollaborator", err)
+ return
}
ctx.Flash.Success(ctx.Tr("repo.settings.remove_collaborator_success"))
ctx.Redirect(ctx.Repo.RepoLink + "/settings/collaboration")
return
}
- names, err := models.GetCollaboratorNames(repoLink)
+ users, err := ctx.Repo.Repository.GetCollaborators()
if err != nil {
ctx.Handle(500, "GetCollaborators", err)
return
}
- collaborators := make([]*models.User, 0, len(names))
- for _, name := range names {
- u, err := models.GetUserByName(name)
- if err != nil {
- ctx.Handle(500, "GetUserByName", err)
- return
- }
- // Does not show organization members.
- if ctx.Repo.Owner.IsOrganization() && ctx.Repo.Owner.IsOrgMember(u.Id) {
- continue
- }
- collaborators = append(collaborators, u)
- }
- ctx.Data["Collaborators"] = collaborators
+ ctx.Data["Collaborators"] = users
ctx.HTML(200, COLLABORATION)
}
} else {
// Normal user.
ctxUser = ctx.User
- collaborates, err := models.GetCollaborativeRepos(ctxUser.Name)
+ collaborates, err := ctx.User.GetAccessibleRepositories()
if err != nil {
- ctx.Handle(500, "GetCollaborativeRepos", err)
+ ctx.Handle(500, "GetAccessibleRepositories", err)
return
}
- ctx.Data["CollaborateCount"] = len(collaborates)
- ctx.Data["CollaborativeRepos"] = collaborates
+
+ repositories := make([]*models.Repository, 0, len(collaborates))
+ for repo := range collaborates {
+ repositories = append(repositories, repo)
+ }
+
+ ctx.Data["CollaborateCount"] = len(repositories)
+ ctx.Data["CollaborativeRepos"] = repositories
}
ctx.Data["ContextUser"] = ctxUser
projects / gitea.git / commitdiff