Drop 0.5.x support

models/migrations/migrations.go

@@ -13,7 +13,6 @@ import (
 	"path"
 	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/Unknwon/com"
 	"github.com/go-xorm/xorm"
@@ -24,7 +23,7 @@ import (
 	gouuid "github.com/gogits/gogs/modules/uuid"
 )
 
-const _MIN_DB_VER = 0
+const _MIN_DB_VER = 4
 
 type Migration interface {
 	Description() string
@@ -58,10 +57,6 @@ type Version struct {
 // If you want to "retire" a migration, remove it from the top of the list and
 // update _MIN_VER_DB accordingly
 var migrations = []Migration{
-	NewMigration("generate collaboration from access", accessToCollaboration),    // V0 -> V1:v0.5.13
-	NewMigration("make authorize 4 if team is owners", ownerTeamUpdate),          // V1 -> V2:v0.5.13
-	NewMigration("refactor access table to use id's", accessRefactor),            // V2 -> V3:v0.5.13
-	NewMigration("generate team-repo from team", teamToTeamRepo),                 // V3 -> V4:v0.5.13
 	NewMigration("fix locale file load panic", fixLocaleFileLoadPanic),           // V4 -> V5:v0.6.0
 	NewMigration("trim action compare URL prefix", trimCommitActionAppUrlPrefix), // V5 -> V6:v0.6.3
 	NewMigration("generate issue-label from issue", issueToIssueLabel),           // V6 -> V7:v0.6.4
@@ -81,24 +76,9 @@ func Migrate(x *xorm.Engine) error {
 	if err != nil {
 		return fmt.Errorf("get: %v", err)
 	} else if !has {
-		// If the user table does not exist it is a fresh installation and we
-		// can skip all migrations.
-		needsMigration, err := x.IsTableExist("user")
-		if err != nil {
-			return err
-		}
-		if needsMigration {
-			isEmpty, err := x.IsTableEmpty("user")
-			if err != nil {
-				return err
-			}
-			// If the user table is empty it is a fresh installation and we can
-			// skip all migrations.
-			needsMigration = !isEmpty
-		}
-		if !needsMigration {
-			currentVersion.Version = int64(_MIN_DB_VER + len(migrations))
-		}
+		// If the version record does not exist we think
+		// it is a fresh installation and we can skip all migrations.
+		currentVersion.Version = int64(_MIN_DB_VER + len(migrations))
 
 		if _, err = x.InsertOne(currentVersion); err != nil {
 			return fmt.Errorf("insert: %v", err)
@@ -107,7 +87,8 @@ func Migrate(x *xorm.Engine) error {
 
 	v := currentVersion.Version
 	if _MIN_DB_VER > v {
-		log.Fatal(4, "Gogs no longer supports auto-migration from your previously installed version. Please try to upgrade to a lower version first, then upgrade to current version.")
+		log.Fatal(4, `Gogs no longer supports auto-migration from your previously installed version. 
+Please try to upgrade to a lower version (>= v0.6.0) first, then upgrade to current version.`)
 		return nil
 	}
 
@@ -137,276 +118,6 @@ func sessionRelease(sess *xorm.Session) {
 	sess.Close()
 }
 
-func accessToCollaboration(x *xorm.Engine) (err 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
-	}
-
-	if err = x.Sync(new(Collaboration)); err != nil {
-		return fmt.Errorf("sync: %v", err)
-	}
-
-	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 {
-		if strings.Contains(err.Error(), "no such column") {
-			return nil
-		}
-		return err
-	}
-
-	sess := x.NewSession()
-	defer sessionRelease(sess)
-	if err = sess.Begin(); err != nil {
-		return err
-	}
-
-	offset := strings.Split(time.Now().String(), " ")[2]
-	for _, result := range results {
-		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]
-
-		results, err := sess.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
-		}
-		if len(results) < 1 {
-			continue
-		}
-
-		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 := com.StrTo(member["memberid"]).MustInt64()
-			// We can skip all cases that a user is member of the owning organization
-			if memberID == userID {
-				isMember = true
-			}
-		}
-		if isMember {
-			continue
-		}
-
-		results, err = sess.Query("SELECT id FROM `repository` WHERE owner_id=? AND lower_name=?", ownerID, repoName)
-		if err != nil {
-			return err
-		} else if len(results) < 1 {
-			continue
-		}
-
-		collaboration := &Collaboration{
-			UserID: userID,
-			RepoID: com.StrTo(results[0]["id"]).MustInt64(),
-		}
-		has, err := sess.Get(collaboration)
-		if err != nil {
-			return err
-		} else if has {
-			continue
-		}
-
-		collaboration.Created = created
-		if _, err = sess.InsertOne(collaboration); err != nil {
-			return err
-		}
-	}
-
-	return sess.Commit()
-}
-
-func ownerTeamUpdate(x *xorm.Engine) (err error) {
-	if _, err := x.Exec("UPDATE `team` SET authorize=4 WHERE lower_name=?", "owners"); err != nil {
-		return fmt.Errorf("update owner team table: %v", err)
-	}
-	return nil
-}
-
-func accessRefactor(x *xorm.Engine) (err error) {
-	type (
-		AccessMode int
-		Access     struct {
-			ID     int64 `xorm:"pk autoincr"`
-			UserID int64 `xorm:"UNIQUE(s)"`
-			RepoID int64 `xorm:"UNIQUE(s)"`
-			Mode   AccessMode
-		}
-		UserRepo struct {
-			UserID int64
-			RepoID int64
-		}
-	)
-
-	// We consiously don't start a session yet as we make only reads for now, no writes
-
-	accessMap := make(map[UserRepo]AccessMode, 50)
-
-	results, err := x.Query("SELECT r.id AS `repo_id`, r.is_private AS `is_private`, r.owner_id AS `owner_id`, u.type AS `owner_type` FROM `repository` r LEFT JOIN `user` u ON r.owner_id=u.id")
-	if err != nil {
-		return fmt.Errorf("select repositories: %v", err)
-	}
-	for _, repo := range results {
-		repoID := com.StrTo(repo["repo_id"]).MustInt64()
-		isPrivate := com.StrTo(repo["is_private"]).MustInt() > 0
-		ownerID := com.StrTo(repo["owner_id"]).MustInt64()
-		ownerIsOrganization := com.StrTo(repo["owner_type"]).MustInt() > 0
-
-		results, err := x.Query("SELECT `user_id` FROM `collaboration` WHERE repo_id=?", repoID)
-		if err != nil {
-			return fmt.Errorf("select collaborators: %v", err)
-		}
-		for _, user := range results {
-			userID := com.StrTo(user["user_id"]).MustInt64()
-			accessMap[UserRepo{userID, repoID}] = 2 // WRITE ACCESS
-		}
-
-		if !ownerIsOrganization {
-			continue
-		}
-
-		// The minimum level to add a new access record,
-		// because public repository has implicit open access.
-		minAccessLevel := AccessMode(0)
-		if !isPrivate {
-			minAccessLevel = 1
-		}
-
-		repoString := "$" + string(repo["repo_id"]) + "|"
-
-		results, err = x.Query("SELECT `id`,`authorize`,`repo_ids` FROM `team` WHERE org_id=? AND authorize>? ORDER BY `authorize` ASC", ownerID, int(minAccessLevel))
-		if err != nil {
-			if strings.Contains(err.Error(), "no such column") {
-				return nil
-			}
-			return fmt.Errorf("select teams from org: %v", err)
-		}
-
-		for _, team := range results {
-			if !strings.Contains(string(team["repo_ids"]), repoString) {
-				continue
-			}
-			teamID := com.StrTo(team["id"]).MustInt64()
-			mode := AccessMode(com.StrTo(team["authorize"]).MustInt())
-
-			results, err := x.Query("SELECT `uid` FROM `team_user` WHERE team_id=?", teamID)
-			if err != nil {
-				return fmt.Errorf("select users from team: %v", err)
-			}
-			for _, user := range results {
-				userID := com.StrTo(user["uid"]).MustInt64()
-				accessMap[UserRepo{userID, repoID}] = mode
-			}
-		}
-	}
-
-	// Drop table can't be in a session (at least not in sqlite)
-	if _, err = x.Exec("DROP TABLE `access`"); err != nil {
-		return fmt.Errorf("drop access table: %v", err)
-	}
-
-	// Now we start writing so we make a session
-	sess := x.NewSession()
-	defer sessionRelease(sess)
-	if err = sess.Begin(); err != nil {
-		return err
-	}
-
-	if err = sess.Sync2(new(Access)); err != nil {
-		return fmt.Errorf("sync: %v", err)
-	}
-
-	accesses := make([]*Access, 0, len(accessMap))
-	for ur, mode := range accessMap {
-		accesses = append(accesses, &Access{UserID: ur.UserID, RepoID: ur.RepoID, Mode: mode})
-	}
-
-	if _, err = sess.Insert(accesses); err != nil {
-		return fmt.Errorf("insert accesses: %v", err)
-	}
-
-	return sess.Commit()
-}
-
-func teamToTeamRepo(x *xorm.Engine) error {
-	type TeamRepo struct {
-		ID     int64 `xorm:"pk autoincr"`
-		OrgID  int64 `xorm:"INDEX"`
-		TeamID int64 `xorm:"UNIQUE(s)"`
-		RepoID int64 `xorm:"UNIQUE(s)"`
-	}
-
-	teamRepos := make([]*TeamRepo, 0, 50)
-
-	results, err := x.Query("SELECT `id`,`org_id`,`repo_ids` FROM `team`")
-	if err != nil {
-		if strings.Contains(err.Error(), "no such column") {
-			return nil
-		}
-		return fmt.Errorf("select teams: %v", err)
-	}
-	for _, team := range results {
-		orgID := com.StrTo(team["org_id"]).MustInt64()
-		teamID := com.StrTo(team["id"]).MustInt64()
-
-		// #1032: legacy code can have duplicated IDs for same repository.
-		mark := make(map[int64]bool)
-		for _, idStr := range strings.Split(string(team["repo_ids"]), "|") {
-			repoID := com.StrTo(strings.TrimPrefix(idStr, "$")).MustInt64()
-			if repoID == 0 || mark[repoID] {
-				continue
-			}
-
-			mark[repoID] = true
-			teamRepos = append(teamRepos, &TeamRepo{
-				OrgID:  orgID,
-				TeamID: teamID,
-				RepoID: repoID,
-			})
-		}
-	}
-
-	sess := x.NewSession()
-	defer sessionRelease(sess)
-	if err = sess.Begin(); err != nil {
-		return err
-	}
-
-	if err = sess.Sync2(new(TeamRepo)); err != nil {
-		return fmt.Errorf("sync2: %v", err)
-	} else if _, err = sess.Insert(teamRepos); err != nil {
-		return fmt.Errorf("insert team-repos: %v", err)
-	}
-
-	return sess.Commit()
-}
-
 func fixLocaleFileLoadPanic(_ *xorm.Engine) error {
 	cfg, err := ini.Load(setting.CustomConf)
 	if err != nil {
@@ -494,7 +205,8 @@ func issueToIssueLabel(x *xorm.Engine) error {
 	issueLabels := make([]*IssueLabel, 0, 50)
 	results, err := x.Query("SELECT `id`,`label_ids` FROM `issue`")
 	if err != nil {
-		if strings.Contains(err.Error(), "no such column") {
+		if strings.Contains(err.Error(), "no such column") ||
+			strings.Contains(err.Error(), "Unknown column") {
 			return nil
 		}
 		return fmt.Errorf("select issues: %v", err)
@@ -653,6 +365,9 @@ func renamePullRequestFields(x *xorm.Engine) (err error) {
 			Index:      com.StrTo(pr["pull_index"]).MustInt64(),
 			HeadBranch: string(pr["head_barcnh"]),
 		}
+		if pull.Index == 0 {
+			continue
+		}
 		if _, err = sess.Id(pull.ID).Update(pull); err != nil {
 			return err
 		}

public/js/gogs.js

@@ -220,7 +220,7 @@ function initRepository() {
 
     // File list and commits
     if ($('.repository.file.list').length > 0 ||
-         ('.repository.commits').length > 0) {
+        ('.repository.commits').length > 0) {
         initFilterSearchDropdown('.choose.reference .dropdown');
 
         $('.reference.column').click(function () {
@@ -411,7 +411,7 @@ function initRepository() {
         $status_btn.click(function () {
             $('#status').val($status_btn.data('status-val'));
             $('#comment-form').submit();
-        })
+        });
     }
 
     // Diff