models.LoadModelsConfig()
- if models.UseSQLite3 {
+ if setting.UseSQLite3 {
workDir, _ := setting.WorkDir()
os.Chdir(workDir)
}
import (
"strings"
"time"
-
- "github.com/go-xorm/xorm"
)
type AccessType int
Created time.Time `xorm:"CREATED"`
}
-// AddAccess adds new access record.
-func AddAccess(access *Access) error {
+func addAccess(e Engine, access *Access) error {
access.UserName = strings.ToLower(access.UserName)
access.RepoName = strings.ToLower(access.RepoName)
- _, err := x.Insert(access)
+ _, err := e.Insert(access)
return err
}
+// AddAccess adds new access record.
+func AddAccess(access *Access) error {
+ return addAccess(x, access)
+}
+
+func updateAccess(e Engine, access *Access) error {
+ if _, err := e.Id(access.Id).Update(access); err != nil {
+ return err
+ }
+ return nil
+}
+
// UpdateAccess updates access information.
func UpdateAccess(access *Access) error {
access.UserName = strings.ToLower(access.UserName)
access.RepoName = strings.ToLower(access.RepoName)
- _, err := x.Id(access.Id).Update(access)
- return err
+ return updateAccess(x, access)
}
-// DeleteAccess deletes access record.
-func DeleteAccess(access *Access) error {
- _, err := x.Delete(access)
+func deleteAccess(e Engine, access *Access) error {
+ _, err := e.Delete(access)
return err
}
-// UpdateAccess updates access information with session for rolling back.
-func UpdateAccessWithSession(sess *xorm.Session, access *Access) error {
- if _, err := sess.Id(access.Id).Update(access); err != nil {
- sess.Rollback()
- return err
- }
- return nil
+// DeleteAccess deletes access record.
+func DeleteAccess(access *Access) error {
+ return deleteAccess(x, access)
}
// HasAccess returns true if someone can read or write to given repository.
if err != nil {
return nil, err
}
- err = repo.GetOwner()
- if err != nil {
+ if err = repo.GetOwner(); err != nil {
return nil, err
+ } else if repo.OwnerId == u.Id {
+ continue
}
repos[repo] = access.Mode
}
}
// NewIssueUserPairs adds new issue-user pairs for new issue of repository.
-func NewIssueUserPairs(repo *Repository, iid, oid, pid, aid int64) (err error) {
- iu := &IssueUser{IssueId: iid, RepoId: repo.Id}
-
- us, err := repo.GetCollaborators()
+func NewIssueUserPairs(repo *Repository, issueID, orgID, posterID, assigneeID int64) (err error) {
+ users, err := repo.GetCollaborators()
if err != nil {
return err
}
+ iu := &IssueUser{
+ IssueId: issueID,
+ RepoId: repo.Id,
+ }
+
isNeedAddPoster := true
- for _, u := range us {
+ for _, u := range users {
iu.Uid = u.Id
- iu.IsPoster = iu.Uid == pid
+ iu.IsPoster = iu.Uid == posterID
if isNeedAddPoster && iu.IsPoster {
isNeedAddPoster = false
}
- iu.IsAssigned = iu.Uid == aid
+ iu.IsAssigned = iu.Uid == assigneeID
if _, err = x.Insert(iu); err != nil {
return err
}
}
if isNeedAddPoster {
- iu.Uid = pid
+ iu.Uid = posterID
iu.IsPoster = true
- iu.IsAssigned = iu.Uid == aid
+ iu.IsAssigned = iu.Uid == assigneeID
if _, err = x.Insert(iu); err != nil {
return err
}
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
package migrations
import (
"errors"
- "strconv"
+ "fmt"
"strings"
"time"
+ "github.com/Unknwon/com"
"github.com/go-xorm/xorm"
+
+ "github.com/gogits/gogs/modules/setting"
)
+const _DB_VER = 1
+
type migration func(*xorm.Engine) error
// The version table. Should have only one row with id==1
// Migrate database to current version
func Migrate(x *xorm.Engine) error {
if err := x.Sync(new(Version)); err != nil {
- return err
+ return fmt.Errorf("sync: %v", err)
}
currentVersion := &Version{Id: 1}
has, err := x.Get(currentVersion)
if err != nil {
- return err
+ return fmt.Errorf("get: %v", 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 {
+ // 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
+ return fmt.Errorf("insert: %v", err)
}
}
v := currentVersion.Version
-
for i, migration := range migrations[v:] {
if err = migration(x); err != nil {
- return err
+ return fmt.Errorf("run migration: %v", err)
}
currentVersion.Version = v + int64(i) + 1
if _, err = x.Id(1).Update(currentVersion); err != nil {
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"`
+ ID int64 `xorm:"pk autoincr"`
+ RepoID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
+ UserID int64 `xorm:"UNIQUE(s) INDEX NOT NULL"`
+ Created time.Time
}
x.Sync(new(Collaboration))
- sql := `SELECT u.id AS uid, a.repo_name AS repo, a.mode AS mode, a.created as created FROM access a JOIN user u ON a.user_name=u.lower_name`
- results, err := x.Query(sql)
+ results, err := x.Query("SELECT u.id AS `uid`, a.repo_name AS `repo`, a.mode AS `mode`, a.created as `created` FROM `access` a JOIN `user` u ON a.user_name=u.lower_name")
if err != nil {
return err
}
+ offset := strings.Split(time.Now().String(), " ")[2]
for _, result := range results {
- userID := mustParseInt64(result["uid"])
- repoRefName := string(result["repo"])
- mode := mustParseInt64(result["mode"])
- created := result["created"]
-
- //Collaborators must have write access
+ mode := com.StrTo(result["mode"]).MustInt64()
+ // Collaborators must have write access.
if mode < 2 {
continue
}
+ userID := com.StrTo(result["uid"]).MustInt64()
+ repoRefName := string(result["repo"])
+
+ var created time.Time
+ switch {
+ case setting.UseSQLite3:
+ created, _ = time.Parse(time.RFC3339, string(result["created"]))
+ case setting.UseMySQL:
+ created, _ = time.Parse("2006-01-02 15:04:05-0700", string(result["created"])+offset)
+ case setting.UsePostgreSQL:
+ created, _ = time.Parse("2006-01-02T15:04:05Z-0700", string(result["created"])+offset)
+ }
+
// find owner of repository
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)
+ results, err := x.Query("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=?", ownerName)
if err != nil {
return err
}
continue
}
- ownerID := mustParseInt64(results[0]["uid"])
+ ownerID := com.StrTo(results[0]["uid"]).MustInt64()
if ownerID == userID {
continue
}
// test if user is member of owning organization
isMember := false
for _, member := range results {
- memberID := mustParseInt64(member["memberid"])
+ memberID := com.StrTo(member["memberid"]).MustInt64()
// We can skip all cases that a user is member of the owning organization
if memberID == userID {
isMember = true
continue
}
- sql = `SELECT id FROM repository WHERE owner_id=? AND lower_name=?`
- results, err = x.Query(sql, ownerID, repoName)
+ results, err = x.Query("SELECT id FROM `repository` WHERE owner_id=? AND lower_name=?", ownerID, repoName)
if err != nil {
return err
}
continue
}
- repoID := results[0]["id"]
-
- sql = `INSERT INTO collaboration (user_id, repo_id, created) VALUES (?,?,?)`
- _, err = x.Exec(sql, userID, repoID, created)
- if err != nil {
+ if _, err = x.InsertOne(&Collaboration{
+ UserID: userID,
+ RepoID: com.StrTo(results[0]["id"]).MustInt64(),
+ Created: created,
+ }); err != nil {
return err
}
}
}
EnableSQLite3 bool
- UseSQLite3 bool
)
func init() {
tables = append(tables,
- new(User), new(PublicKey), new(Follow), new(Oauth2), new(AccessToken),
- new(Repository), new(Watch), new(Star), new(Action), new(Access),
+ new(User), new(PublicKey), new(Oauth2), new(AccessToken),
+ new(Repository), new(Collaboration), new(Access),
+ new(Watch), new(Star), new(Follow), new(Action),
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(Collaboration))
+ new(Notice), new(EmailAddress))
}
func LoadModelsConfig() {
sec := setting.Cfg.Section("database")
DbCfg.Type = sec.Key("DB_TYPE").String()
- if DbCfg.Type == "sqlite3" {
- UseSQLite3 = true
+ switch DbCfg.Type {
+ case "sqlite3":
+ setting.UseSQLite3 = true
+ case "mysql":
+ setting.UseMySQL = true
+ case "postgres":
+ setting.UsePostgreSQL = true
}
DbCfg.Host = sec.Key("HOST").String()
DbCfg.Name = sec.Key("NAME").String()
}
if err = migrations.Migrate(x); err != nil {
- return err
+ return fmt.Errorf("migrate: %v", err)
}
if err = x.StoreEngine("InnoDB").Sync2(tables...); err != nil {
for i := range accesses {
accesses[i].RepoName = userName + "/" + newRepoName
- if err = UpdateAccessWithSession(sess, &accesses[i]); err != nil {
+ if err = updateAccess(sess, &accesses[i]); err != nil {
+ sess.Rollback()
return err
}
}
return x.Count(&Repository{OwnerId: user.Id})
}
-// 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
- }
-
- 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 users, nil
-}
-
-// Add collaborator and accompanying access
-func (r *Repository) AddCollaborator(u *User) error {
- collaboration := &Collaboration{RepoID: r.Id, UserID: u.Id}
-
- has, err := x.Get(collaboration)
- if err != nil {
- return err
- }
- if has {
- return nil
- }
-
- if _, err = x.InsertOne(collaboration); err != nil {
- return err
- }
-
- if err = r.GetOwner(); err != nil {
- return err
- }
-
- return AddAccess(&Access{UserName: u.LowerName, RepoName: path.Join(r.Owner.LowerName, r.LowerName), Mode: WRITABLE})
-}
-
-// 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
- }
-
- 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 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 nil
-}
-
type SearchOption struct {
Keyword string
Uid int64
})
}
+// _________ .__ .__ ___. __ .__
+// \_ ___ \ ____ | | | | _____ \_ |__ ________________ _/ |_|__| ____ ____
+// / \ \/ / _ \| | | | \__ \ | __ \ / _ \_ __ \__ \\ __\ |/ _ \ / \
+// \ \___( <_> ) |_| |__/ __ \| \_\ ( <_> ) | \// __ \| | | ( <_> ) | \
+// \______ /\____/|____/____(____ /___ /\____/|__| (____ /__| |__|\____/|___| /
+// \/ \/ \/ \/ \/
+
+// 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"`
+}
+
+// Add collaborator and accompanying access
+func (r *Repository) AddCollaborator(u *User) error {
+ collaboration := &Collaboration{RepoID: r.Id, UserID: u.Id}
+ has, err := x.Get(collaboration)
+ if err != nil {
+ return err
+ } else if has {
+ return nil
+ }
+
+ if err = r.GetOwner(); err != nil {
+ return err
+ }
+
+ sess := x.NewSession()
+ defer sess.Close()
+ if err = sess.Begin(); err != nil {
+ return err
+ }
+
+ if _, err = sess.InsertOne(collaboration); err != nil {
+ sess.Rollback()
+ return err
+ } else if err = addAccess(sess, &Access{
+ UserName: u.LowerName,
+ RepoName: path.Join(r.Owner.LowerName, r.LowerName),
+ Mode: WRITABLE}); err != nil {
+ sess.Rollback()
+ return err
+ }
+
+ return sess.Commit()
+}
+
+// GetCollaborators returns the collaborators for a repository
+func (r *Repository) GetCollaborators() ([]*User, error) {
+ collaborations := make([]*Collaboration, 0, 5)
+ if err := x.Where("repo_id=?", r.Id).Find(&collaborations); err != nil {
+ return nil, err
+ }
+
+ 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 users, nil
+}
+
+// Delete collaborator and accompanying access
+func (r *Repository) DeleteCollaborator(u *User) (err error) {
+ collaboration := &Collaboration{RepoID: r.Id, UserID: u.Id}
+ has, err := x.Get(collaboration)
+ if err != nil {
+ return err
+ } else if !has {
+ return nil
+ }
+
+ if err = r.GetOwner(); err != nil {
+ return err
+ }
+
+ sess := x.NewSession()
+ defer sess.Close()
+ if err = sess.Begin(); err != nil {
+ return err
+ }
+
+ needDelete := true
+ if r.Owner.IsOrganization() {
+ auth, err := getHighestAuthorize(sess, r.Owner.Id, u.Id, r.Id, 0)
+ if err != nil {
+ sess.Rollback()
+ return err
+ }
+ if auth > 0 {
+ needDelete = false
+ }
+ }
+ if needDelete {
+ if err = deleteAccess(sess, &Access{
+ UserName: u.LowerName,
+ RepoName: path.Join(r.Owner.LowerName, r.LowerName),
+ Mode: WRITABLE}); err != nil {
+ sess.Rollback()
+ return err
+ } else if _, err = sess.Delete(collaboration); err != nil {
+ sess.Rollback()
+ return err
+ }
+ }
+
+ return sess.Commit()
+}
+
// __ __ __ .__
// / \ / \_____ _/ |_ ____ | |__
// \ \/\/ /\__ \\ __\/ ___\| | \
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"`
-}
if strings.HasPrefix(accesses[i].RepoName, u.LowerName+"/") {
accesses[i].RepoName = strings.Replace(accesses[i].RepoName, u.LowerName, newUserName, 1)
}
- if err = UpdateAccessWithSession(sess, &accesses[i]); err != nil {
+ if err = updateAccess(sess, &accesses[i]); err != nil {
+ sess.Rollback()
return err
}
}
// if the access is not the user's access (already updated above)
if accesses[j].UserName != u.LowerName {
accesses[j].RepoName = newUserName + "/" + repos[i].LowerName
- if err = UpdateAccessWithSession(sess, &accesses[j]); err != nil {
+ if err = updateAccess(sess, &accesses[j]); err != nil {
+ sess.Rollback()
return err
}
}
func GetUserByKeyId(keyId int64) (*User, error) {
user := new(User)
- rawSql := "SELECT a.* FROM `user` AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?"
- has, err := x.Sql(rawSql, keyId).Get(user)
+ has, err := x.Sql("SELECT a.* FROM `user` AS a, public_key AS b WHERE a.id = b.owner_id AND b.id=?", keyId).Get(user)
if err != nil {
return nil, err
} else if !has {
CookieRememberName string
ReverseProxyAuthUser string
+ // Database settings.
+ UseSQLite3 bool
+ UseMySQL bool
+ UsePostgreSQL bool
+
// Webhook settings.
Webhook struct {
TaskInterval int
</div>
<footer id="footer">
<div class="container clear">
- <p class="left" id="footer-rights">© 2015 GoGits · {{.i18n.Tr "version"}}: {{AppVer}} · {{.i18n.Tr "page"}}: <strong>{{LoadTimes .PageStartTime}}</strong> ·
+ <p class="left" id="footer-rights">© 2015 Gogs · {{.i18n.Tr "version"}}: {{AppVer}} · {{.i18n.Tr "page"}}: <strong>{{LoadTimes .PageStartTime}}</strong> ·
{{.i18n.Tr "template"}}: <strong>{{call .TmplLoadTimes}}</strong></p>
<div class="right" id="footer-links">
projects / gitea.git / commitdiff