bench-forgejo/models/migrations/migrations.go

package migrations

import (
	"errors"
	"strconv"
	"strings"
	"time"

	"github.com/go-xorm/xorm"
)

type migration func(*xorm.Engine) error

// The version table. Should have only one row with id==1
type Version struct {
	Id      int64
	Version int64
}

// 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{
	accessToCollaboration,
	accessRefactor,
}

// Migrate database to current version
func Migrate(x *xorm.Engine) error {
	if err := x.Sync(new(Version)); err != nil {
		return err
	}

	currentVersion := &Version{Id: 1}
	has, err := x.Get(currentVersion)
	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
		}
	}

	v := currentVersion.Version

	for i, migration := range migrations[v:] {
		if err = migration(x); err != nil {
			return err
		}
		currentVersion.Version = v + int64(i) + 1
		if _, err = x.Id(1).Update(currentVersion); err != nil {
			return err
		}
	}
	return nil
}

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, a.created as created 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"])
		created := result["created"]

		//Collaborators must have write access
		if mode < 2 {
			continue
		}

		// 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)
		if err != nil {
			return err
		}
		if len(results) < 1 {
			continue
		}

		ownerID := mustParseInt64(results[0]["uid"])
		if ownerID == userID {
			continue
		}

		// test if user is member of owning organization
		isMember := false
		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 {
				isMember = true
			}
		}
		if isMember {
			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, created) VALUES (?,?,?)`
		_, err = x.Exec(sql, userID, repoID, created)
		if err != nil {
			return err
		}
	}
	return nil
}

func accessRefactor(x *xorm.Engine) error {
	//TODO
	return nil
}